[solanum.git] / modules / m_xline.c

/* modules/m_xline.c
 * 
 *  Copyright (C) 2002-2003 Lee Hardy <lee@leeh.co.uk>
 *  Copyright (C) 2002-2005 ircd-ratbox development team
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1.Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * 2.Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * 3.The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * $Id$
 */

#include "stdinc.h"
#include "send.h"
#include "channel.h"
#include "client.h"
#include "common.h"
#include "config.h"
#include "class.h"
#include "ircd.h"
#include "numeric.h"
#include "logger.h"
#include "s_serv.h"
#include "whowas.h"
#include "match.h"
#include "hash.h"
#include "msg.h"
#include "parse.h"
#include "modules.h"
#include "s_conf.h"
#include "s_newconf.h"
#include "reject.h"
#include "bandbi.h"

static int mo_xline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
static int ms_xline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
static int me_xline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
static int mo_unxline(struct Client *client_p, struct Client *source_p, int parc,
		      const char *parv[]);
static int ms_unxline(struct Client *client_p, struct Client *source_p, int parc,
		      const char *parv[]);
static int me_unxline(struct Client *client_p, struct Client *source_p, int parc,
		      const char *parv[]);

struct Message xline_msgtab = {
	"XLINE", 0, 0, 0, MFLG_SLOW,
	{mg_unreg, mg_not_oper, {ms_xline, 5}, {ms_xline, 5}, {me_xline, 5}, {mo_xline, 3}}
};

struct Message unxline_msgtab = {
	"UNXLINE", 0, 0, 0, MFLG_SLOW,
	{mg_unreg, mg_not_oper, {ms_unxline, 3}, {ms_unxline, 3}, {me_unxline, 2}, {mo_unxline, 2}}
};

mapi_clist_av1 xline_clist[] = { &xline_msgtab, &unxline_msgtab, NULL };

DECLARE_MODULE_AV1(xline, NULL, NULL, xline_clist, NULL, NULL, "$Revision$");

static int valid_xline(struct Client *, const char *, const char *);
static void apply_xline(struct Client *client_p, const char *name,
			const char *reason, int temp_time);
static void propagate_xline(struct Client *source_p, const char *target,
			    int temp_time, const char *name, const char *type, const char *reason);
static void cluster_xline(struct Client *source_p, int temp_time,
			  const char *name, const char *reason);

static void handle_remote_xline(struct Client *source_p, int temp_time,
				const char *name, const char *reason);
static void handle_remote_unxline(struct Client *source_p, const char *name);

static void remove_xline(struct Client *source_p, const char *name);


/* m_xline()
 *
 * parv[1] - thing to xline
 * parv[2] - optional type/reason
 * parv[3] - reason
 */
static int
mo_xline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	struct ConfItem *aconf;
	const char *name;
	const char *reason;
	const char *target_server = NULL;
	int temp_time;
	int loc = 1;

	if(!IsOperXline(source_p))
	{
		sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "xline");
		return 0;
	}

	if((temp_time = valid_temp_time(parv[loc])) >= 0)
		loc++;
	/* we just set temp_time to -1! */
	else
		temp_time = 0;

	name = parv[loc];
	loc++;

	/* XLINE <gecos> ON <server> :<reason> */
	if(parc >= loc + 2 && !irccmp(parv[loc], "ON"))
	{
		if(!IsOperRemoteBan(source_p))
		{
			sendto_one(source_p, form_str(ERR_NOPRIVS),
				   me.name, source_p->name, "remoteban");
			return 0;
		}

		target_server = parv[loc + 1];
		loc += 2;
	}

	if(parc <= loc || EmptyString(parv[loc]))
	{
		sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
			   me.name, source_p->name, "XLINE");
		return 0;
	}

	reason = parv[loc];

	if(target_server != NULL)
	{
		propagate_xline(source_p, target_server, temp_time, name, "2", reason);

		if(!match(target_server, me.name))
			return 0;
	}
	else if(rb_dlink_list_length(&cluster_conf_list) > 0)
		cluster_xline(source_p, temp_time, name, reason);

	if((aconf = find_xline_mask(name)) != NULL)
	{
		sendto_one(source_p, ":%s NOTICE %s :[%s] already X-Lined by [%s] - %s",
			   me.name, source_p->name, name, aconf->host, aconf->passwd);
		return 0;
	}

	if(!valid_xline(source_p, name, reason))
		return 0;

	apply_xline(source_p, name, reason, temp_time);

	return 0;
}

/* ms_xline()
 *
 * handles a remote xline
 */
static int
ms_xline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	/* parv[0]  parv[1]      parv[2]  parv[3]  parv[4]
	 * oper     target serv  xline    type     reason
	 */
	propagate_xline(source_p, parv[1], 0, parv[2], parv[3], parv[4]);

	if(!IsPerson(source_p))
		return 0;

	/* destined for me? */
	if(!match(parv[1], me.name))
		return 0;

	handle_remote_xline(source_p, 0, parv[2], parv[4]);
	return 0;
}

static int
me_xline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	/* time name type :reason */
	if(!IsPerson(source_p))
		return 0;

	handle_remote_xline(source_p, atoi(parv[1]), parv[2], parv[4]);
	return 0;
}

static void
handle_remote_xline(struct Client *source_p, int temp_time, const char *name, const char *reason)
{
	struct ConfItem *aconf;

	if(!find_shared_conf(source_p->username, source_p->host,
			     source_p->servptr->name,
			     (temp_time > 0) ? SHARED_TXLINE : SHARED_PXLINE))
		return;

	if(!valid_xline(source_p, name, reason))
		return;

	/* already xlined */
	if((aconf = find_xline_mask(name)) != NULL)
	{
		sendto_one_notice(source_p, ":[%s] already X-Lined by [%s] - %s", name, aconf->host,
				  aconf->passwd);
		return;
	}

	apply_xline(source_p, name, reason, temp_time);
}

/* valid_xline()
 *
 * inputs	- client xlining, gecos, reason and whether to warn
 * outputs	-
 * side effects - checks the xline for validity, erroring if needed
 */
static int
valid_xline(struct Client *source_p, const char *gecos, const char *reason)
{
	if(EmptyString(reason))
	{
		sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
			   get_id(&me, source_p), get_id(source_p, source_p), "XLINE");
		return 0;
	}

	if(strchr(reason, ':') != NULL)
	{
		sendto_one_notice(source_p, ":Invalid character ':' in comment");
		return 0;
	}

	if(strchr(reason, '"'))
	{
		sendto_one_notice(source_p, ":Invalid character '\"' in comment");
		return 0;
	}

	if(!valid_wild_card_simple(gecos))
	{
		sendto_one_notice(source_p,
				  ":Please include at least %d non-wildcard "
				  "characters with the xline",
				  ConfigFileEntry.min_nonwildcard_simple);
		return 0;
	}

	return 1;
}

void
apply_xline(struct Client *source_p, const char *name, const char *reason, int temp_time)
{
	struct ConfItem *aconf;

	aconf = make_conf();
	aconf->status = CONF_XLINE;
	aconf->created = rb_current_time();
	aconf->host = rb_strdup(name);
	aconf->passwd = rb_strdup(reason);
	collapse(aconf->host);

	if(temp_time > 0)
	{
		aconf->hold = rb_current_time() + temp_time;

		sendto_realops_snomask(SNO_GENERAL, L_ALL,
				       "%s added temporary %d min. X-Line for [%s] [%s]",
				       get_oper_name(source_p), temp_time / 60,
				       aconf->host, reason);
		ilog(L_KLINE, "X %s %d %s %s",
		     get_oper_name(source_p), temp_time / 60, name, reason);
		sendto_one_notice(source_p, ":Added temporary %d min. X-Line [%s]",
				  temp_time / 60, aconf->host);
	}
	else
	{
		sendto_realops_snomask(SNO_GENERAL, L_ALL, "%s added X-Line for [%s] [%s]",
				       get_oper_name(source_p), aconf->host, aconf->passwd);
		sendto_one_notice(source_p, ":Added X-Line for [%s] [%s]",
				  aconf->host, aconf->passwd);

		bandb_add(BANDB_XLINE, source_p, aconf->host, NULL, aconf->passwd, NULL, 0);
		ilog(L_KLINE, "X %s 0 %s %s", get_oper_name(source_p), name, aconf->passwd);
	}

	rb_dlinkAddAlloc(aconf, &xline_conf_list);
	check_xlines();
}

static void
propagate_xline(struct Client *source_p, const char *target,
		int temp_time, const char *name, const char *type, const char *reason)
{
	if(!temp_time)
	{
		sendto_match_servs(source_p, target, CAP_CLUSTER, NOCAPS,
				   "XLINE %s %s %s :%s", target, name, type, reason);
		sendto_match_servs(source_p, target, CAP_ENCAP, CAP_CLUSTER,
				   "ENCAP %s XLINE %d %s 2 :%s", target, temp_time, name, reason);
	}
	else
		sendto_match_servs(source_p, target, CAP_ENCAP, NOCAPS,
				   "ENCAP %s XLINE %d %s %s :%s",
				   target, temp_time, name, type, reason);
}

static void
cluster_xline(struct Client *source_p, int temp_time, const char *name, const char *reason)
{
	struct remote_conf *shared_p;
	rb_dlink_node *ptr;

	RB_DLINK_FOREACH(ptr, cluster_conf_list.head)
	{
		shared_p = ptr->data;

		/* old protocol cant handle temps, and we dont really want
		 * to convert them to perm.. --fl
		 */
		if(!temp_time)
		{
			if(!(shared_p->flags & SHARED_PXLINE))
				continue;

			sendto_match_servs(source_p, shared_p->server, CAP_CLUSTER, NOCAPS,
					   "XLINE %s %s 2 :%s", shared_p->server, name, reason);
			sendto_match_servs(source_p, shared_p->server, CAP_ENCAP, CAP_CLUSTER,
					   "ENCAP %s XLINE 0 %s 2 :%s",
					   shared_p->server, name, reason);
		}
		else if(shared_p->flags & SHARED_TXLINE)
			sendto_match_servs(source_p, shared_p->server, CAP_ENCAP, NOCAPS,
					   "ENCAP %s XLINE %d %s 2 :%s",
					   shared_p->server, temp_time, name, reason);
	}
}

/* mo_unxline()
 *
 * parv[1] - thing to unxline
 */
static int
mo_unxline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	if(!IsOperXline(source_p))
	{
		sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "xline");
		return 0;
	}

	if(parc == 4 && !(irccmp(parv[2], "ON")))
	{
		if(!IsOperRemoteBan(source_p))
		{
			sendto_one(source_p, form_str(ERR_NOPRIVS),
				   me.name, source_p->name, "remoteban");
			return 0;
		}

		propagate_generic(source_p, "UNXLINE", parv[3], CAP_CLUSTER, "%s", parv[1]);

		if(match(parv[3], me.name) == 0)
			return 0;
	}
	else if(rb_dlink_list_length(&cluster_conf_list))
		cluster_generic(source_p, "UNXLINE", SHARED_UNXLINE, CAP_CLUSTER, "%s", parv[1]);

	remove_xline(source_p, parv[1]);

	return 0;
}

/* ms_unxline()
 *
 * handles a remote unxline
 */
static int
ms_unxline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	/* parv[0]  parv[1]        parv[2]
	 * oper     target server  gecos
	 */
	propagate_generic(source_p, "UNXLINE", parv[1], CAP_CLUSTER, "%s", parv[2]);

	if(!match(parv[1], me.name))
		return 0;

	if(!IsPerson(source_p))
		return 0;

	handle_remote_unxline(source_p, parv[2]);
	return 0;
}

static int
me_unxline(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	/* name */
	if(!IsPerson(source_p))
		return 0;

	handle_remote_unxline(source_p, parv[1]);
	return 0;
}

static void
handle_remote_unxline(struct Client *source_p, const char *name)
{
	if(!find_shared_conf(source_p->username, source_p->host,
			     source_p->servptr->name, SHARED_UNXLINE))
		return;

	remove_xline(source_p, name);

	return;
}

static void
remove_xline(struct Client *source_p, const char *name)
{
	struct ConfItem *aconf;
	rb_dlink_node *ptr;

	RB_DLINK_FOREACH(ptr, xline_conf_list.head)
	{
		aconf = ptr->data;

		if(!irccmp(aconf->host, name))
		{
			if(!aconf->hold)
			{
				bandb_del(BANDB_XLINE, aconf->host, NULL);

				sendto_one_notice(source_p, ":X-Line for [%s] is removed", aconf->host);
				sendto_realops_snomask(SNO_GENERAL, L_ALL,
						       "%s has removed the X-Line for: [%s]",
						       get_oper_name(source_p), aconf->host);
				ilog(L_KLINE, "UX %s %s", get_oper_name(source_p), aconf->host);
			}
			else
			{
				sendto_one_notice(source_p, ":X-Line for [%s] is removed", name);
				sendto_realops_snomask(SNO_GENERAL, L_ALL,
						       "%s has removed the temporary X-Line for: [%s]",
						       get_oper_name(source_p), name);
				ilog(L_KLINE, "UX %s %s", get_oper_name(source_p), name);
			}

			remove_reject_mask(aconf->host, NULL);
			free_conf(aconf);
			rb_dlinkDestroy(ptr, &xline_conf_list);
			return;
		}
	}

	sendto_one_notice(source_p, ":No X-Line for %s", name);

	return;
}
Commit	Line	Data
212380e3 AC	1	/* modules/m_xline.c
	2	*
	3	* Copyright (C) 2002-2003 Lee Hardy <lee@leeh.co.uk>
	4	* Copyright (C) 2002-2005 ircd-ratbox development team
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions are
	8	* met:
	9	*
	10	* 1.Redistributions of source code must retain the above copyright notice,
	11	* this list of conditions and the following disclaimer.
	12	* 2.Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in the
	14	* documentation and/or other materials provided with the distribution.
	15	* 3.The name of the author may not be used to endorse or promote products
	16	* derived from this software without specific prior written permission.
	17	*
	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	20	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	21	* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
	22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	23	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	24	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	25	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	26	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	27	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	28	* POSSIBILITY OF SUCH DAMAGE.
	29	*
8bbeb278	30	* $Id$
212380e3 AC	31	*/
	32
	33	#include "stdinc.h"
212380e3 AC	34	#include "send.h"
	35	#include "channel.h"
	36	#include "client.h"
	37	#include "common.h"
	38	#include "config.h"
	39	#include "class.h"
	40	#include "ircd.h"
	41	#include "numeric.h"
4016731b	42	#include "logger.h"
212380e3 AC	43	#include "s_serv.h"
212380e3 AC	44	#include "whowas.h"
4562c604	45	#include "match.h"
212380e3 AC	46	#include "hash.h"
	47	#include "msg.h"
	48	#include "parse.h"
	49	#include "modules.h"
	50	#include "s_conf.h"
	51	#include "s_newconf.h"
35f6f850	52	#include "reject.h"
8bbeb278	53	#include "bandbi.h"
212380e3 AC	54
	55	static int mo_xline(struct Client client_p, struct Client source_p, int parc, const char *parv[]);
	56	static int ms_xline(struct Client client_p, struct Client source_p, int parc, const char *parv[]);
	57	static int me_xline(struct Client client_p, struct Client source_p, int parc, const char *parv[]);
8bbeb278 AC	58	static int mo_unxline(struct Client client_p, struct Client source_p, int parc,
	59	const char *parv[]);
	60	static int ms_unxline(struct Client client_p, struct Client source_p, int parc,
	61	const char *parv[]);
	62	static int me_unxline(struct Client client_p, struct Client source_p, int parc,
	63	const char *parv[]);
212380e3 AC	64
	65	struct Message xline_msgtab = {
	66	"XLINE", 0, 0, 0, MFLG_SLOW,
	67	{mg_unreg, mg_not_oper, {ms_xline, 5}, {ms_xline, 5}, {me_xline, 5}, {mo_xline, 3}}
	68	};
8bbeb278	69
212380e3 AC	70	struct Message unxline_msgtab = {
	71	"UNXLINE", 0, 0, 0, MFLG_SLOW,
	72	{mg_unreg, mg_not_oper, {ms_unxline, 3}, {ms_unxline, 3}, {me_unxline, 2}, {mo_unxline, 2}}
	73	};
	74
8bbeb278 AC	75	mapi_clist_av1 xline_clist[] = { &xline_msgtab, &unxline_msgtab, NULL };
	76
	77	DECLARE_MODULE_AV1(xline, NULL, NULL, xline_clist, NULL, NULL, "$Revision$");
212380e3	78
8bbeb278 AC	79	static int valid_xline(struct Client , const char , const char *);
8bbeb278 AC	80	static void apply_xline(struct Client client_p, const char name,
212380e3	81	const char *reason, int temp_time);
212380e3	82	static void propagate_xline(struct Client source_p, const char target,
8bbeb278	83	int temp_time, const char name, const char type, const char *reason);
212380e3	84	static void cluster_xline(struct Client *source_p, int temp_time,
8bbeb278	85	const char name, const char reason);
212380e3 AC	86
	87	static void handle_remote_xline(struct Client *source_p, int temp_time,
	88	const char name, const char reason);
	89	static void handle_remote_unxline(struct Client source_p, const char name);
	90
60c96e64	91	static void remove_xline(struct Client source_p, const char name);
212380e3 AC	92
	93
	94	/* m_xline()
	95	*
	96	* parv[1] - thing to xline
	97	* parv[2] - optional type/reason
	98	* parv[3] - reason
	99	*/
	100	static int
	101	mo_xline(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	102	{
	103	struct ConfItem *aconf;
	104	const char *name;
	105	const char *reason;
	106	const char *target_server = NULL;
	107	int temp_time;
	108	int loc = 1;
	109
	110	if(!IsOperXline(source_p))
	111	{
8bbeb278	112	sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "xline");
212380e3 AC	113	return 0;
	114	}
	115
	116	if((temp_time = valid_temp_time(parv[loc])) >= 0)
	117	loc++;
	118	/* we just set temp_time to -1! */
	119	else
	120	temp_time = 0;
	121
	122	name = parv[loc];
	123	loc++;
	124
	125	/* XLINE <gecos> ON <server> :<reason> */
8bbeb278	126	if(parc >= loc + 2 && !irccmp(parv[loc], "ON"))
212380e3 AC	127	{
	128	if(!IsOperRemoteBan(source_p))
	129	{
	130	sendto_one(source_p, form_str(ERR_NOPRIVS),
8bbeb278	131	me.name, source_p->name, "remoteban");
212380e3 AC	132	return 0;
	133	}
	134
8bbeb278	135	target_server = parv[loc + 1];
212380e3 AC	136	loc += 2;
	137	}
	138
	139	if(parc <= loc \|\| EmptyString(parv[loc]))
	140	{
	141	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
8bbeb278	142	me.name, source_p->name, "XLINE");
212380e3 AC	143	return 0;
	144	}
	145
	146	reason = parv[loc];
	147
	148	if(target_server != NULL)
	149	{
8bbeb278	150	propagate_xline(source_p, target_server, temp_time, name, "2", reason);
212380e3 AC	151
	152	if(!match(target_server, me.name))
	153	return 0;
	154	}
5b96d9a6	155	else if(rb_dlink_list_length(&cluster_conf_list) > 0)
8bbeb278	156	cluster_xline(source_p, temp_time, name, reason);
212380e3	157
8bbeb278	158	if((aconf = find_xline_mask(name)) != NULL)
212380e3 AC	159	{
212380e3 AC	160	sendto_one(source_p, ":%s NOTICE %s :[%s] already X-Lined by [%s] - %s",
23959371	161	me.name, source_p->name, name, aconf->host, aconf->passwd);
212380e3 AC	162	return 0;
	163	}
	164
8bbeb278	165	if(!valid_xline(source_p, name, reason))
212380e3 AC	166	return 0;
212380e3 AC	167
8bbeb278	168	apply_xline(source_p, name, reason, temp_time);
212380e3 AC	169
	170	return 0;
	171	}
	172
	173	/* ms_xline()
	174	*
	175	* handles a remote xline
	176	*/
	177	static int
	178	ms_xline(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	179	{
8bbeb278 AC	180	/* parv[0] parv[1] parv[2] parv[3] parv[4]
8bbeb278 AC	181	* oper target serv xline type reason
212380e3 AC	182	*/
	183	propagate_xline(source_p, parv[1], 0, parv[2], parv[3], parv[4]);
	184
	185	if(!IsPerson(source_p))
	186	return 0;
	187
	188	/* destined for me? */
	189	if(!match(parv[1], me.name))
	190	return 0;
	191
	192	handle_remote_xline(source_p, 0, parv[2], parv[4]);
	193	return 0;
	194	}
	195
	196	static int
	197	me_xline(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	198	{
	199	/* time name type :reason */
	200	if(!IsPerson(source_p))
	201	return 0;
	202
	203	handle_remote_xline(source_p, atoi(parv[1]), parv[2], parv[4]);
	204	return 0;
	205	}
	206
	207	static void
8bbeb278	208	handle_remote_xline(struct Client source_p, int temp_time, const char name, const char *reason)
212380e3 AC	209	{
	210	struct ConfItem *aconf;
	211
	212	if(!find_shared_conf(source_p->username, source_p->host,
8bbeb278 AC	213	source_p->servptr->name,
8bbeb278 AC	214	(temp_time > 0) ? SHARED_TXLINE : SHARED_PXLINE))
212380e3 AC	215	return;
212380e3 AC	216
8bbeb278	217	if(!valid_xline(source_p, name, reason))
212380e3 AC	218	return;
	219
	220	/* already xlined */
0fdb2570	221	if((aconf = find_xline_mask(name)) != NULL)
212380e3	222	{
23959371	223	sendto_one_notice(source_p, ":[%s] already X-Lined by [%s] - %s", name, aconf->host,
8bbeb278	224	aconf->passwd);
212380e3 AC	225	return;
	226	}
	227
	228	apply_xline(source_p, name, reason, temp_time);
	229	}
	230
	231	/* valid_xline()
	232	*
8bbeb278	233	* inputs - client xlining, gecos, reason and whether to warn
212380e3 AC	234	* outputs -
	235	* side effects - checks the xline for validity, erroring if needed
	236	*/
	237	static int
8bbeb278	238	valid_xline(struct Client source_p, const char gecos, const char *reason)
212380e3 AC	239	{
	240	if(EmptyString(reason))
	241	{
	242	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
8bbeb278	243	get_id(&me, source_p), get_id(source_p, source_p), "XLINE");
cc169c94 JT	244	return 0;
	245	}
	246
212380e3 AC	247	if(strchr(reason, ':') != NULL)
212380e3 AC	248	{
8bbeb278	249	sendto_one_notice(source_p, ":Invalid character ':' in comment");
212380e3 AC	250	return 0;
	251	}
	252
	253	if(strchr(reason, '"'))
	254	{
8bbeb278	255	sendto_one_notice(source_p, ":Invalid character '\"' in comment");
212380e3 AC	256	return 0;
	257	}
	258
	259	if(!valid_wild_card_simple(gecos))
	260	{
	261	sendto_one_notice(source_p,
	262	":Please include at least %d non-wildcard "
	263	"characters with the xline",
	264	ConfigFileEntry.min_nonwildcard_simple);
	265	return 0;
	266	}
	267
	268	return 1;
	269	}
	270
	271	void
8bbeb278	272	apply_xline(struct Client source_p, const char name, const char *reason, int temp_time)
212380e3 AC	273	{
	274	struct ConfItem *aconf;
	275
	276	aconf = make_conf();
	277	aconf->status = CONF_XLINE;
b52c2949	278	aconf->created = rb_current_time();
4418166c	279	aconf->host = rb_strdup(name);
8bbeb278	280	aconf->passwd = rb_strdup(reason);
23959371	281	collapse(aconf->host);
212380e3	282
8bbeb278	283	if(temp_time > 0)
212380e3	284	{
8bbeb278	285	aconf->hold = rb_current_time() + temp_time;
212380e3	286
8bbeb278 AC	287	sendto_realops_snomask(SNO_GENERAL, L_ALL,
	288	"%s added temporary %d min. X-Line for [%s] [%s]",
	289	get_oper_name(source_p), temp_time / 60,
23959371	290	aconf->host, reason);
8bbeb278 AC	291	ilog(L_KLINE, "X %s %d %s %s",
	292	get_oper_name(source_p), temp_time / 60, name, reason);
	293	sendto_one_notice(source_p, ":Added temporary %d min. X-Line [%s]",
23959371	294	temp_time / 60, aconf->host);
8bbeb278 AC	295	}
8bbeb278 AC	296	else
212380e3	297	{
8bbeb278	298	sendto_realops_snomask(SNO_GENERAL, L_ALL, "%s added X-Line for [%s] [%s]",
23959371	299	get_oper_name(source_p), aconf->host, aconf->passwd);
8bbeb278	300	sendto_one_notice(source_p, ":Added X-Line for [%s] [%s]",
23959371	301	aconf->host, aconf->passwd);
8bbeb278	302
23959371	303	bandb_add(BANDB_XLINE, source_p, aconf->host, NULL, aconf->passwd, NULL, 0);
f36d4fdd	304	ilog(L_KLINE, "X %s 0 %s %s", get_oper_name(source_p), name, aconf->passwd);
212380e3	305	}
8bbeb278 AC	306
	307	rb_dlinkAddAlloc(aconf, &xline_conf_list);
	308	check_xlines();
212380e3 AC	309	}
212380e3 AC	310
8bbeb278	311	static void
212380e3	312	propagate_xline(struct Client source_p, const char target,
8bbeb278	313	int temp_time, const char name, const char type, const char *reason)
212380e3 AC	314	{
	315	if(!temp_time)
	316	{
	317	sendto_match_servs(source_p, target, CAP_CLUSTER, NOCAPS,
8bbeb278	318	"XLINE %s %s %s :%s", target, name, type, reason);
212380e3	319	sendto_match_servs(source_p, target, CAP_ENCAP, CAP_CLUSTER,
8bbeb278	320	"ENCAP %s XLINE %d %s 2 :%s", target, temp_time, name, reason);
212380e3 AC	321	}
	322	else
	323	sendto_match_servs(source_p, target, CAP_ENCAP, NOCAPS,
8bbeb278 AC	324	"ENCAP %s XLINE %d %s %s :%s",
8bbeb278 AC	325	target, temp_time, name, type, reason);
212380e3	326	}
8bbeb278	327
212380e3	328	static void
8bbeb278	329	cluster_xline(struct Client source_p, int temp_time, const char name, const char *reason)
212380e3 AC	330	{
212380e3 AC	331	struct remote_conf *shared_p;
5b96d9a6	332	rb_dlink_node *ptr;
212380e3	333
5b96d9a6	334	RB_DLINK_FOREACH(ptr, cluster_conf_list.head)
212380e3 AC	335	{
	336	shared_p = ptr->data;
	337
	338	/* old protocol cant handle temps, and we dont really want
	339	* to convert them to perm.. --fl
	340	*/
	341	if(!temp_time)
	342	{
	343	if(!(shared_p->flags & SHARED_PXLINE))
	344	continue;
	345
	346	sendto_match_servs(source_p, shared_p->server, CAP_CLUSTER, NOCAPS,
8bbeb278	347	"XLINE %s %s 2 :%s", shared_p->server, name, reason);
212380e3	348	sendto_match_servs(source_p, shared_p->server, CAP_ENCAP, CAP_CLUSTER,
8bbeb278 AC	349	"ENCAP %s XLINE 0 %s 2 :%s",
8bbeb278 AC	350	shared_p->server, name, reason);
212380e3 AC	351	}
	352	else if(shared_p->flags & SHARED_TXLINE)
	353	sendto_match_servs(source_p, shared_p->server, CAP_ENCAP, NOCAPS,
8bbeb278 AC	354	"ENCAP %s XLINE %d %s 2 :%s",
8bbeb278 AC	355	shared_p->server, temp_time, name, reason);
212380e3 AC	356	}
	357	}
	358
	359	/* mo_unxline()
	360	*
	361	* parv[1] - thing to unxline
	362	*/
	363	static int
	364	mo_unxline(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	365	{
	366	if(!IsOperXline(source_p))
	367	{
8bbeb278	368	sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "xline");
212380e3 AC	369	return 0;
	370	}
	371
	372	if(parc == 4 && !(irccmp(parv[2], "ON")))
	373	{
	374	if(!IsOperRemoteBan(source_p))
	375	{
	376	sendto_one(source_p, form_str(ERR_NOPRIVS),
8bbeb278	377	me.name, source_p->name, "remoteban");
212380e3 AC	378	return 0;
	379	}
	380
8bbeb278	381	propagate_generic(source_p, "UNXLINE", parv[3], CAP_CLUSTER, "%s", parv[1]);
212380e3 AC	382
	383	if(match(parv[3], me.name) == 0)
	384	return 0;
	385	}
5b96d9a6	386	else if(rb_dlink_list_length(&cluster_conf_list))
8bbeb278	387	cluster_generic(source_p, "UNXLINE", SHARED_UNXLINE, CAP_CLUSTER, "%s", parv[1]);
212380e3	388
212380e3 AC	389	remove_xline(source_p, parv[1]);
	390
	391	return 0;
	392	}
	393
	394	/* ms_unxline()
	395	*
	396	* handles a remote unxline
	397	*/
	398	static int
	399	ms_unxline(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	400	{
8bbeb278 AC	401	/* parv[0] parv[1] parv[2]
8bbeb278 AC	402	* oper target server gecos
212380e3	403	*/
8bbeb278	404	propagate_generic(source_p, "UNXLINE", parv[1], CAP_CLUSTER, "%s", parv[2]);
212380e3 AC	405
	406	if(!match(parv[1], me.name))
	407	return 0;
	408
	409	if(!IsPerson(source_p))
	410	return 0;
	411
	412	handle_remote_unxline(source_p, parv[2]);
	413	return 0;
	414	}
	415
	416	static int
	417	me_unxline(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	418	{
	419	/* name */
	420	if(!IsPerson(source_p))
	421	return 0;
	422
	423	handle_remote_unxline(source_p, parv[1]);
	424	return 0;
	425	}
	426
	427	static void
	428	handle_remote_unxline(struct Client source_p, const char name)
	429	{
	430	if(!find_shared_conf(source_p->username, source_p->host,
8bbeb278	431	source_p->servptr->name, SHARED_UNXLINE))
212380e3 AC	432	return;
212380e3 AC	433
212380e3 AC	434	remove_xline(source_p, name);
	435
	436	return;
	437	}
	438
60c96e64	439	static void
5408b484	440	remove_xline(struct Client source_p, const char name)
212380e3 AC	441	{
212380e3 AC	442	struct ConfItem *aconf;
5b96d9a6	443	rb_dlink_node *ptr;
212380e3	444
5b96d9a6	445	RB_DLINK_FOREACH(ptr, xline_conf_list.head)
212380e3 AC	446	{
	447	aconf = ptr->data;
	448
23959371	449	if(!irccmp(aconf->host, name))
212380e3	450	{
8bbeb278	451	if(!aconf->hold)
5408b484	452	{
8bbeb278 AC	453	bandb_del(BANDB_XLINE, aconf->host, NULL);
	454
	455	sendto_one_notice(source_p, ":X-Line for [%s] is removed", aconf->host);
	456	sendto_realops_snomask(SNO_GENERAL, L_ALL,
	457	"%s has removed the X-Line for: [%s]",
	458	get_oper_name(source_p), aconf->host);
	459	ilog(L_KLINE, "UX %s %s", get_oper_name(source_p), aconf->host);
5408b484 JT	460	}
	461	else
	462	{
8bbeb278	463	sendto_one_notice(source_p, ":X-Line for [%s] is removed", name);
5408b484	464	sendto_realops_snomask(SNO_GENERAL, L_ALL,
8bbeb278 AC	465	"%s has removed the temporary X-Line for: [%s]",
	466	get_oper_name(source_p), name);
	467	ilog(L_KLINE, "UX %s %s", get_oper_name(source_p), name);
5408b484	468	}
8bbeb278	469
23959371	470	remove_reject_mask(aconf->host, NULL);
212380e3	471	free_conf(aconf);
555ac41f	472	rb_dlinkDestroy(ptr, &xline_conf_list);
60c96e64	473	return;
212380e3 AC	474	}
	475	}
	476
8bbeb278	477	sendto_one_notice(source_p, ":No X-Line for %s", name);
5408b484	478
60c96e64	479	return;
212380e3	480	}