[irc/freenode/solanum.git] / modules / m_cap.c

/* modules/m_cap.c
 *
 *  Copyright (C) 2005 Lee Hardy <lee@leeh.co.uk>
 *  Copyright (C) 2005 ircd-ratbox development team
 *  Copyright (C) 2016 William Pitcock <nenolod@dereferenced.org>
 *
 * 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.
 */

#include "stdinc.h"
#include "class.h"
#include "client.h"
#include "match.h"
#include "ircd.h"
#include "numeric.h"
#include "msg.h"
#include "parse.h"
#include "modules.h"
#include "s_serv.h"
#include "s_user.h"
#include "send.h"
#include "s_conf.h"
#include "hash.h"

static const char cap_desc[] = "Provides the commands used for client capability negotiation";

typedef int (*bqcmp)(const void *, const void *);

static void m_cap(struct MsgBuf *, struct Client *, struct Client *, int, const char **);

struct Message cap_msgtab = {
	"CAP", 0, 0, 0, 0,
	{{m_cap, 2}, {m_cap, 2}, mg_ignore, mg_ignore, mg_ignore, {m_cap, 2}}
};

mapi_clist_av1 cap_clist[] = { &cap_msgtab, NULL };

DECLARE_MODULE_AV2(cap, NULL, NULL, cap_clist, NULL, NULL, NULL, NULL, cap_desc);

#define IsCapableEntry(c, e)		IsCapable(c, 1 << (e)->value)
#define HasCapabilityFlag(c, f)		(c->ownerdata != NULL && (((struct ClientCapability *)c->ownerdata)->flags & (f)) == f)

static inline int
clicap_visible(struct Client *client_p, const struct CapabilityEntry *cap)
{
	struct ClientCapability *clicap;

	/* orphaned caps shouldn't be visible */
	if (cap->flags & CAP_ORPHANED)
		return 0;

	if (cap->ownerdata == NULL)
		return 1;

	clicap = cap->ownerdata;
	if (clicap->visible == NULL)
		return 1;

	return clicap->visible(client_p);
}

/* clicap_find()
 *   Used iteratively over a buffer, extracts individual cap tokens.
 *
 * Inputs: buffer to start iterating over (NULL to iterate over existing buf)
 *         int pointer to whether the cap token is negated
 *         int pointer to whether we finish with success
 * Ouputs: Cap entry if found, NULL otherwise.
 */
static struct CapabilityEntry *
clicap_find(const char *data, int *negate, int *finished)
{
	static char buf[BUFSIZE];
	static char *p;
	struct CapabilityEntry *cap;
	char *s;

	*negate = 0;

	if(data)
	{
		rb_strlcpy(buf, data, sizeof(buf));
		p = buf;
	}

	if(*finished)
		return NULL;

	/* skip any whitespace */
	while(*p && IsSpace(*p))
		p++;

	if(EmptyString(p))
	{
		*finished = 1;
		return NULL;
	}

	if(*p == '-')
	{
		*negate = 1;
		p++;

		/* someone sent a '-' without a parameter.. */
		if(*p == '\0')
			return NULL;
	}

	if((s = strchr(p, ' ')))
		*s++ = '\0';

	if((cap = capability_find(cli_capindex, p)) != NULL)
	{
		if(s)
			p = s;
		else
			*finished = 1;
	}

	return cap;
}

/* clicap_generate()
 *   Generates a list of capabilities.
 *
 * Inputs: client to send to, subcmd to send,
 *         flags to match against: 0 to do none, -1 if client has no flags
 * Outputs: None
 */
static void
clicap_generate(struct Client *source_p, const char *subcmd, int flags)
{
	static char buf_prefix[DATALEN + 1];
	static char buf_list[DATALEN + 1];
	const char *str_cont = " * :";
	const char *str_final = " :";
	int len_prefix;
	int max_list;
	struct CapabilityEntry *entry;
	rb_dictionary_iter iter;

	buf_prefix[0] = '\0';
	len_prefix = rb_snprintf_try_append(buf_prefix, sizeof(buf_prefix),
			":%s CAP %s %s",
			me.name,
			EmptyString(source_p->name) ? "*" : source_p->name,
			subcmd);

	/* shortcut, nothing to do */
	if (flags == -1 || len_prefix < 0) {
		sendto_one(source_p, "%s%s", buf_prefix, str_final);
		return;
	}

	buf_list[0] = '\0';
	max_list = sizeof(buf_prefix) - len_prefix - strlen(str_cont);

	for (int pass = 0; pass < 2; pass++)
	RB_DICTIONARY_FOREACH(entry, &iter, cli_capindex->cap_dict) {
		struct ClientCapability *clicap = entry->ownerdata;
		const char *data = NULL;

		if (pass == 0 && !HasCapabilityFlag(entry, CLICAP_FLAGS_PRIORITY))
			continue;
		else if (pass == 1 && HasCapabilityFlag(entry, CLICAP_FLAGS_PRIORITY))
			continue;

		if (!IsCapableEntry(source_p, entry) && ConfigFileEntry.hidden_caps != NULL)
		{
			size_t i;
			for (i = 0; ConfigFileEntry.hidden_caps[i] != NULL; i++)
			{
				if (!rb_strcasecmp(entry->cap, ConfigFileEntry.hidden_caps[i]))
					break;
			}
			if (ConfigFileEntry.hidden_caps[i] != NULL)
				continue;
		}

		if (flags && !IsCapableEntry(source_p, entry))
			continue;

		if (!clicap_visible(source_p, entry))
			continue;

		if (!flags && (source_p->flags & FLAGS_CLICAP_DATA) && clicap != NULL && clicap->data != NULL)
			data = clicap->data(source_p);

		for (int attempts = 0; attempts < 2; attempts++) {
			if (rb_snprintf_try_append(buf_list, max_list, "%s%s%s%s",
					buf_list[0] == '\0' ? "" : " ", /* space between caps */
					entry->cap,
					data != NULL ? "=" : "", /* '=' between cap and data */
					data != NULL ? data : "") < 0
					&& buf_list[0] != '\0') {

				if (!(source_p->flags & FLAGS_CLICAP_DATA)) {
					/* the client doesn't support multiple lines */
					continue;
				}

				/* doesn't fit in the buffer, output what we have */
				sendto_one(source_p, "%s%s%s", buf_prefix, str_cont, buf_list);

				/* reset the buffer and go around the loop one more time */
				buf_list[0] = '\0';
			} else {
				break;
			}
		}
	}

	sendto_one(source_p, "%s%s%s", buf_prefix, str_final, buf_list);
}

static void
cap_ack(struct Client *source_p, const char *arg)
{
	struct CapabilityEntry *cap;
	int capadd = 0, capdel = 0;
	int finished = 0, negate;

	if(EmptyString(arg))
		return;

	for(cap = clicap_find(arg, &negate, &finished); cap;
	    cap = clicap_find(NULL, &negate, &finished))
	{
		/* sent an ACK for something they havent REQd */
		if(!IsCapableEntry(source_p, cap))
			continue;

		if(negate)
		{
			/* dont let them ack something sticky off */
			if(HasCapabilityFlag(cap, CLICAP_FLAGS_STICKY))
				continue;

			capdel |= (1 << cap->value);
		}
		else
			capadd |= (1 << cap->value);
	}

	source_p->localClient->caps |= capadd;
	source_p->localClient->caps &= ~capdel;
}

static void
cap_end(struct Client *source_p, const char *arg)
{
	if(IsRegistered(source_p))
		return;

	source_p->flags &= ~FLAGS_CLICAP;

	if(source_p->name[0] && source_p->flags & FLAGS_SENTUSER)
	{
		register_local_user(source_p, source_p);
	}
}

static void
cap_list(struct Client *source_p, const char *arg)
{
	/* list of what theyre currently using */
	clicap_generate(source_p, "LIST",
			source_p->localClient->caps ? source_p->localClient->caps : -1);
}

static void
cap_ls(struct Client *source_p, const char *arg)
{
	int caps_version = 301;

	if(!IsRegistered(source_p))
		source_p->flags |= FLAGS_CLICAP;

	if (!EmptyString(arg)) {
		caps_version = atoi(arg);
	}

	if (caps_version >= 302) {
		source_p->flags |= FLAGS_CLICAP_DATA;
		source_p->localClient->caps |= CLICAP_CAP_NOTIFY;
	}

	/* list of what we support */
	clicap_generate(source_p, "LS", 0);
}

static void
cap_req(struct Client *source_p, const char *arg)
{
	char ack_buf[DATALEN+1];
	struct CapabilityEntry *cap;
	int capadd = 0, capdel = 0;
	int finished = 0, negate;
	int ret;
	hook_data_cap_change hdata;

	if(!IsRegistered(source_p))
		source_p->flags |= FLAGS_CLICAP;

	if(EmptyString(arg))
		return;

	ret = snprintf(ack_buf, sizeof ack_buf, ":%s CAP %s ACK :%s",
			me.name, EmptyString(source_p->name)? "*" : source_p->name, arg);

	if (ret < 0 || ret > DATALEN)
	{
		sendto_one(source_p, ":%s CAP %s NAK :%s",
			me.name, EmptyString(source_p->name) ? "*" : source_p->name, arg);
		return;
	}

	for(cap = clicap_find(arg, &negate, &finished); cap;
	    cap = clicap_find(NULL, &negate, &finished))
	{
		if(negate)
		{
			if(HasCapabilityFlag(cap, CLICAP_FLAGS_STICKY))
			{
				finished = 0;
				break;
			}

			capdel |= (1 << cap->value);
		}
		else
		{
			if (!clicap_visible(source_p, cap))
			{
				finished = 0;
				break;
			}

			capadd |= (1 << cap->value);
		}

	}

	if(!finished)
	{
		sendto_one(source_p, ":%s CAP %s NAK :%s",
			me.name, EmptyString(source_p->name) ? "*" : source_p->name, arg);
		return;
	}

	sendto_one(source_p, "%s", ack_buf);

	hdata.client = source_p;
	hdata.oldcaps = source_p->localClient->caps;
	hdata.add = capadd;
	hdata.del = capdel;

	source_p->localClient->caps |= capadd;
	source_p->localClient->caps &= ~capdel;

	call_hook(h_cap_change, &hdata);
}

static struct clicap_cmd
{
	const char *cmd;
	void (*func)(struct Client *source_p, const char *arg);
} clicap_cmdlist[] = {
	/* This list *MUST* be in alphabetical order */
	{ "ACK",	cap_ack		},
	{ "END",	cap_end		},
	{ "LIST",	cap_list	},
	{ "LS",		cap_ls		},
	{ "REQ",	cap_req		},
};

static int
clicap_cmd_search(const char *command, struct clicap_cmd *entry)
{
	return irccmp(command, entry->cmd);
}

static void
m_cap(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	struct clicap_cmd *cmd;

	if(!(cmd = bsearch(parv[1], clicap_cmdlist,
				sizeof(clicap_cmdlist) / sizeof(struct clicap_cmd),
				sizeof(struct clicap_cmd), (bqcmp) clicap_cmd_search)))
	{
		sendto_one(source_p, form_str(ERR_INVALIDCAPCMD),
				me.name, EmptyString(source_p->name) ? "*" : source_p->name,
				parv[1]);
		return;
	}

	(cmd->func)(source_p, parv[2]);
}
Commit	Line	Data
212380e3	1	/* modules/m_cap.c
55abcbb2	2	*
212380e3 WP	3	* Copyright (C) 2005 Lee Hardy <lee@leeh.co.uk>
212380e3 WP	4	* Copyright (C) 2005 ircd-ratbox development team
32df5e96	5	* Copyright (C) 2016 William Pitcock <nenolod@dereferenced.org>
212380e3 WP	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions are
	9	* met:
	10	*
	11	* 1.Redistributions of source code must retain the above copyright notice,
	12	* this list of conditions and the following disclaimer.
	13	* 2.Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3.The name of the author may not be used to endorse or promote products
	17	* derived from this software without specific prior written permission.
	18	*
	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	21	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	22	* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
	23	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	24	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	25	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	26	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	27	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	28	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	29	* POSSIBILITY OF SUCH DAMAGE.
212380e3 WP	30	*/
	31
	32	#include "stdinc.h"
212380e3 WP	33	#include "class.h"
212380e3 WP	34	#include "client.h"
4562c604	35	#include "match.h"
212380e3 WP	36	#include "ircd.h"
	37	#include "numeric.h"
	38	#include "msg.h"
	39	#include "parse.h"
	40	#include "modules.h"
	41	#include "s_serv.h"
	42	#include "s_user.h"
77d3d2db	43	#include "send.h"
bbce62d2	44	#include "s_conf.h"
dafbd7fa	45	#include "hash.h"
212380e3	46
eeabf33a EM	47	static const char cap_desc[] = "Provides the commands used for client capability negotiation";
eeabf33a EM	48
212380e3 WP	49	typedef int (bqcmp)(const void , const void *);
212380e3 WP	50
3c7d6fcc	51	static void m_cap(struct MsgBuf , struct Client , struct Client , int, const char *);
212380e3 WP	52
212380e3 WP	53	struct Message cap_msgtab = {
7baa37a9	54	"CAP", 0, 0, 0, 0,
212380e3 WP	55	{{m_cap, 2}, {m_cap, 2}, mg_ignore, mg_ignore, mg_ignore, {m_cap, 2}}
	56	};
	57
	58	mapi_clist_av1 cap_clist[] = { &cap_msgtab, NULL };
5544da98	59
5544da98	60	DECLARE_MODULE_AV2(cap, NULL, NULL, cap_clist, NULL, NULL, NULL, NULL, cap_desc);
212380e3	61
32df5e96 WP	62	#define IsCapableEntry(c, e) IsCapable(c, 1 << (e)->value)
32df5e96 WP	63	#define HasCapabilityFlag(c, f) (c->ownerdata != NULL && (((struct ClientCapability *)c->ownerdata)->flags & (f)) == f)
212380e3	64
193d4db3	65	static inline int
38ffccf8	66	clicap_visible(struct Client client_p, const struct CapabilityEntry cap)
193d4db3 WP	67	{
	68	struct ClientCapability *clicap;
	69
455d2750 WP	70	/* orphaned caps shouldn't be visible */
	71	if (cap->flags & CAP_ORPHANED)
	72	return 0;
	73
193d4db3 WP	74	if (cap->ownerdata == NULL)
	75	return 1;
	76
	77	clicap = cap->ownerdata;
	78	if (clicap->visible == NULL)
	79	return 1;
	80
38ffccf8	81	return clicap->visible(client_p);
193d4db3 WP	82	}
193d4db3 WP	83
212380e3 WP	84	/* clicap_find()
	85	* Used iteratively over a buffer, extracts individual cap tokens.
	86	*
	87	* Inputs: buffer to start iterating over (NULL to iterate over existing buf)
	88	* int pointer to whether the cap token is negated
	89	* int pointer to whether we finish with success
	90	* Ouputs: Cap entry if found, NULL otherwise.
	91	*/
32df5e96	92	static struct CapabilityEntry *
212380e3 WP	93	clicap_find(const char data, int negate, int *finished)
	94	{
	95	static char buf[BUFSIZE];
	96	static char *p;
32df5e96	97	struct CapabilityEntry *cap;
212380e3 WP	98	char *s;
	99
	100	*negate = 0;
	101
	102	if(data)
	103	{
f427c8b0	104	rb_strlcpy(buf, data, sizeof(buf));
212380e3 WP	105	p = buf;
	106	}
	107
	108	if(*finished)
	109	return NULL;
	110
	111	/* skip any whitespace */
	112	while(p && IsSpace(p))
	113	p++;
	114
	115	if(EmptyString(p))
	116	{
	117	*finished = 1;
	118	return NULL;
	119	}
	120
	121	if(*p == '-')
	122	{
	123	*negate = 1;
	124	p++;
	125
	126	/* someone sent a '-' without a parameter.. */
	127	if(*p == '\0')
	128	return NULL;
	129	}
	130
	131	if((s = strchr(p, ' ')))
	132	*s++ = '\0';
	133
32df5e96	134	if((cap = capability_find(cli_capindex, p)) != NULL)
212380e3 WP	135	{
	136	if(s)
	137	p = s;
	138	else
	139	*finished = 1;
	140	}
	141
	142	return cap;
	143	}
	144
	145	/* clicap_generate()
	146	* Generates a list of capabilities.
	147	*
	148	* Inputs: client to send to, subcmd to send,
ceabbbbf	149	* flags to match against: 0 to do none, -1 if client has no flags
212380e3 WP	150	* Outputs: None
	151	*/
	152	static void
ceabbbbf	153	clicap_generate(struct Client source_p, const char subcmd, int flags)
212380e3	154	{
3fb264ef SA	155	static char buf_prefix[DATALEN + 1];
	156	static char buf_list[DATALEN + 1];
	157	const char str_cont = " :";
	158	const char *str_final = " :";
	159	int len_prefix;
	160	int max_list;
32df5e96	161	struct CapabilityEntry *entry;
4177311e	162	rb_dictionary_iter iter;
212380e3	163
3fb264ef SA	164	buf_prefix[0] = '\0';
	165	len_prefix = rb_snprintf_try_append(buf_prefix, sizeof(buf_prefix),
	166	":%s CAP %s %s",
55abcbb2 KB	167	me.name,
55abcbb2 KB	168	EmptyString(source_p->name) ? "*" : source_p->name,
212380e3 WP	169	subcmd);
212380e3 WP	170
212380e3	171	/* shortcut, nothing to do */
3fb264ef SA	172	if (flags == -1 \|\| len_prefix < 0) {
3fb264ef SA	173	sendto_one(source_p, "%s%s", buf_prefix, str_final);
212380e3 WP	174	return;
	175	}
	176
3fb264ef SA	177	buf_list[0] = '\0';
	178	max_list = sizeof(buf_prefix) - len_prefix - strlen(str_cont);
	179
738b5d29	180	for (int pass = 0; pass < 2; pass++)
3fb264ef	181	RB_DICTIONARY_FOREACH(entry, &iter, cli_capindex->cap_dict) {
ddf62b10 WP	182	struct ClientCapability *clicap = entry->ownerdata;
	183	const char *data = NULL;
	184
738b5d29 EK	185	if (pass == 0 && !HasCapabilityFlag(entry, CLICAP_FLAGS_PRIORITY))
	186	continue;
	187	else if (pass == 1 && HasCapabilityFlag(entry, CLICAP_FLAGS_PRIORITY))
	188	continue;
	189
6ac21a70 EK	190	if (!IsCapableEntry(source_p, entry) && ConfigFileEntry.hidden_caps != NULL)
	191	{
	192	size_t i;
	193	for (i = 0; ConfigFileEntry.hidden_caps[i] != NULL; i++)
	194	{
	195	if (!rb_strcasecmp(entry->cap, ConfigFileEntry.hidden_caps[i]))
	196	break;
	197	}
	198	if (ConfigFileEntry.hidden_caps[i] != NULL)
	199	continue;
	200	}
	201
3fb264ef	202	if (flags && !IsCapableEntry(source_p, entry))
ceabbbbf	203	continue;
212380e3	204
38ffccf8	205	if (!clicap_visible(source_p, entry))
193d4db3	206	continue;
bbce62d2	207
ddf62b10	208	if (!flags && (source_p->flags & FLAGS_CLICAP_DATA) && clicap != NULL && clicap->data != NULL)
38ffccf8	209	data = clicap->data(source_p);
ddf62b10	210
3fb264ef SA	211	for (int attempts = 0; attempts < 2; attempts++) {
	212	if (rb_snprintf_try_append(buf_list, max_list, "%s%s%s%s",
	213	buf_list[0] == '\0' ? "" : " ", /* space between caps */
	214	entry->cap,
	215	data != NULL ? "=" : "", /* '=' between cap and data */
	216	data != NULL ? data : "") < 0
	217	&& buf_list[0] != '\0') {
	218
	219	if (!(source_p->flags & FLAGS_CLICAP_DATA)) {
	220	/* the client doesn't support multiple lines */
f3439650	221	continue;
3fb264ef SA	222	}
	223
	224	/* doesn't fit in the buffer, output what we have */
	225	sendto_one(source_p, "%s%s%s", buf_prefix, str_cont, buf_list);
	226
	227	/* reset the buffer and go around the loop one more time */
	228	buf_list[0] = '\0';
	229	} else {
	230	break;
	231	}
212380e3	232	}
212380e3 WP	233	}
212380e3 WP	234
3fb264ef	235	sendto_one(source_p, "%s%s%s", buf_prefix, str_final, buf_list);
212380e3 WP	236	}
	237
	238	static void
	239	cap_ack(struct Client source_p, const char arg)
	240	{
32df5e96	241	struct CapabilityEntry *cap;
212380e3 WP	242	int capadd = 0, capdel = 0;
	243	int finished = 0, negate;
	244
	245	if(EmptyString(arg))
	246	return;
	247
	248	for(cap = clicap_find(arg, &negate, &finished); cap;
	249	cap = clicap_find(NULL, &negate, &finished))
	250	{
	251	/* sent an ACK for something they havent REQd */
32df5e96	252	if(!IsCapableEntry(source_p, cap))
212380e3 WP	253	continue;
	254
	255	if(negate)
	256	{
	257	/* dont let them ack something sticky off */
32df5e96	258	if(HasCapabilityFlag(cap, CLICAP_FLAGS_STICKY))
212380e3 WP	259	continue;
212380e3 WP	260
32df5e96	261	capdel \|= (1 << cap->value);
212380e3 WP	262	}
212380e3 WP	263	else
32df5e96	264	capadd \|= (1 << cap->value);
212380e3 WP	265	}
	266
	267	source_p->localClient->caps \|= capadd;
	268	source_p->localClient->caps &= ~capdel;
	269	}
	270
212380e3 WP	271	static void
	272	cap_end(struct Client source_p, const char arg)
	273	{
	274	if(IsRegistered(source_p))
	275	return;
	276
095328a7	277	source_p->flags &= ~FLAGS_CLICAP;
212380e3	278
1fb3b1e1	279	if(source_p->name[0] && source_p->flags & FLAGS_SENTUSER)
212380e3	280	{
21251822	281	register_local_user(source_p, source_p);
212380e3 WP	282	}
	283	}
	284
	285	static void
	286	cap_list(struct Client source_p, const char arg)
	287	{
	288	/* list of what theyre currently using */
	289	clicap_generate(source_p, "LIST",
ceabbbbf	290	source_p->localClient->caps ? source_p->localClient->caps : -1);
212380e3 WP	291	}
	292
	293	static void
	294	cap_ls(struct Client source_p, const char arg)
	295	{
3fb264ef SA	296	int caps_version = 301;
3fb264ef SA	297
212380e3	298	if(!IsRegistered(source_p))
095328a7	299	source_p->flags \|= FLAGS_CLICAP;
212380e3	300
3fb264ef SA	301	if (!EmptyString(arg)) {
	302	caps_version = atoi(arg);
	303	}
	304
	305	if (caps_version >= 302) {
ddf62b10	306	source_p->flags \|= FLAGS_CLICAP_DATA;
ba316ed5 WP	307	source_p->localClient->caps \|= CLICAP_CAP_NOTIFY;
ba316ed5 WP	308	}
ddf62b10	309
212380e3	310	/* list of what we support */
ceabbbbf	311	clicap_generate(source_p, "LS", 0);
212380e3 WP	312	}
	313
	314	static void
	315	cap_req(struct Client source_p, const char arg)
	316	{
5d727361	317	char ack_buf[DATALEN+1];
32df5e96	318	struct CapabilityEntry *cap;
212380e3 WP	319	int capadd = 0, capdel = 0;
212380e3 WP	320	int finished = 0, negate;
5d727361	321	int ret;
71f10f83	322	hook_data_cap_change hdata;
212380e3 WP	323
212380e3 WP	324	if(!IsRegistered(source_p))
095328a7	325	source_p->flags \|= FLAGS_CLICAP;
212380e3 WP	326
	327	if(EmptyString(arg))
	328	return;
	329
5d727361 DF	330	ret = snprintf(ack_buf, sizeof ack_buf, ":%s CAP %s ACK :%s",
5d727361 DF	331	me.name, EmptyString(source_p->name)? "*" : source_p->name, arg);
212380e3	332
5d727361 DF	333	if (ret < 0 \|\| ret > DATALEN)
	334	{
	335	sendto_one(source_p, ":%s CAP %s NAK :%s",
	336	me.name, EmptyString(source_p->name) ? "*" : source_p->name, arg);
	337	return;
	338	}
212380e3 WP	339
	340	for(cap = clicap_find(arg, &negate, &finished); cap;
	341	cap = clicap_find(NULL, &negate, &finished))
	342	{
212380e3 WP	343	if(negate)
212380e3 WP	344	{
32df5e96	345	if(HasCapabilityFlag(cap, CLICAP_FLAGS_STICKY))
212380e3 WP	346	{
	347	finished = 0;
	348	break;
	349	}
	350
32df5e96	351	capdel \|= (1 << cap->value);
212380e3 WP	352	}
	353	else
	354	{
38ffccf8	355	if (!clicap_visible(source_p, cap))
bbce62d2	356	{
193d4db3 WP	357	finished = 0;
193d4db3 WP	358	break;
bbce62d2 MT	359	}
bbce62d2 MT	360
32df5e96	361	capadd \|= (1 << cap->value);
212380e3 WP	362	}
212380e3 WP	363
212380e3 WP	364	}
	365
	366	if(!finished)
	367	{
	368	sendto_one(source_p, ":%s CAP %s NAK :%s",
	369	me.name, EmptyString(source_p->name) ? "*" : source_p->name, arg);
	370	return;
	371	}
	372
5d727361	373	sendto_one(source_p, "%s", ack_buf);
212380e3	374
71f10f83 EK	375	hdata.client = source_p;
	376	hdata.oldcaps = source_p->localClient->caps;
	377	hdata.add = capadd;
	378	hdata.del = capdel;
	379
212380e3 WP	380	source_p->localClient->caps \|= capadd;
212380e3 WP	381	source_p->localClient->caps &= ~capdel;
71f10f83 EK	382
71f10f83 EK	383	call_hook(h_cap_change, &hdata);
212380e3 WP	384	}
	385
	386	static struct clicap_cmd
	387	{
	388	const char *cmd;
	389	void (func)(struct Client source_p, const char *arg);
	390	} clicap_cmdlist[] = {
	391	/* This list MUST be in alphabetical order */
	392	{ "ACK", cap_ack },
212380e3 WP	393	{ "END", cap_end },
	394	{ "LIST", cap_list },
	395	{ "LS", cap_ls },
	396	{ "REQ", cap_req },
	397	};
	398
	399	static int
	400	clicap_cmd_search(const char command, struct clicap_cmd entry)
	401	{
	402	return irccmp(command, entry->cmd);
	403	}
	404
3c7d6fcc	405	static void
428ca87b	406	m_cap(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char parv[])
212380e3 WP	407	{
	408	struct clicap_cmd *cmd;
	409
	410	if(!(cmd = bsearch(parv[1], clicap_cmdlist,
	411	sizeof(clicap_cmdlist) / sizeof(struct clicap_cmd),
	412	sizeof(struct clicap_cmd), (bqcmp) clicap_cmd_search)))
	413	{
	414	sendto_one(source_p, form_str(ERR_INVALIDCAPCMD),
48a038f4 JT	415	me.name, EmptyString(source_p->name) ? "*" : source_p->name,
48a038f4 JT	416	parv[1]);
3c7d6fcc	417	return;
212380e3 WP	418	}
	419
	420	(cmd->func)(source_p, parv[2]);
212380e3	421	}