8.2.x/modules/m_cap.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *
 *  Copyright (C) 2004 Kevin L. Mitchell <klmitch@mit.edu>
 *  Copyright (C) 2006 Hybrid Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id$
 */

/** @file
 * @brief Capability negotiation commands
 * @version $Id$
 */

#include "stdinc.h"
#include "client.h"
#include "hash.h"
#include "ircd.h"
#include "numeric.h"
#include "s_conf.h"
#include "s_user.h"
#include "s_serv.h"
#include "send.h"
#include "parse.h"
#include "modules.h"
#include "packet.h"
#include "irc_string.h"


#define CAPFL_HIDDEN    0x0001  /**< Do not advertize this capability */
#define CAPFL_PROHIBIT  0x0002  /**< Client may not set this capability */
#define CAPFL_PROTO     0x0004  /**< Cap must be acknowledged by client */
#define CAPFL_STICKY    0x0008  /**< Cap may not be cleared once set */

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

static struct capabilities
{
  unsigned int cap;
  unsigned int flags;
  const char *name;
  size_t namelen;
} capab_list[] = {
#define _CAP(cap, flags, name)  \
        { (cap), (flags), (name), sizeof(name) - 1 }
  _CAP(CAP_MULTI_PREFIX, 0, "multi-prefix")
#undef _CAP
};

#define CAPAB_LIST_LEN  (sizeof(capab_list) / sizeof(struct capabilities))

static int
capab_sort(const struct capabilities *cap1, const struct capabilities *cap2)
{
  return strcasecmp(cap1->name, cap2->name);
}

static int
capab_search(const char *key, const struct capabilities *cap)
{
  const char *rb = cap->name;

  while (ToLower(*key) == ToLower(*rb)) /* walk equivalent part of strings */
    if (*key++ == '\0')    /* hit the end, all right... */
      return 0;
    else    /* OK, let's move on... */
      rb++;

  /*
   * If the character they differ on happens to be a space, and it happens
   * to be the same length as the capability name, then we've found a
   * match; otherwise, return the difference of the two.
   */
  return (IsSpace(*key) && *rb == '\0') ? 0 : (ToLower(*key) - ToLower(*rb));
}

static struct capabilities *
find_cap(const char **caplist_p, int *neg_p)
{
  static int inited = 0;
  const char *caplist = *caplist_p;
  struct capabilities *cap = NULL;

  *neg_p = 0;    /* clear negative flag... */

  if (!inited)
  {
    /* First, let's sort the array... */
    qsort(capab_list, CAPAB_LIST_LEN, sizeof(struct capabilities), (bqcmp)capab_sort);
    ++inited;
  }

  /* Next, find first non-whitespace character... */
  while (*caplist && IsSpace(*caplist))
    ++caplist;

  /* We are now at the beginning of an element of the list; is it negative? */
  if (*caplist == '-')
  {
    ++caplist;    /* yes; step past the flag... */
    *neg_p = 1;    /* remember that it is negative... */
  }

  /* OK, now see if we can look up the capability... */
  if (*caplist)
  {
    if (!(cap = bsearch(caplist, capab_list, CAPAB_LIST_LEN,
                        sizeof(struct capabilities),
                        (bqcmp)capab_search)))
    {
      /* Couldn't find the capability; advance to first whitespace character */
      while (*caplist && !IsSpace(*caplist))
        ++caplist;
    }
    else
      caplist += cap->namelen; /* advance to end of capability name */
  }

  assert(caplist != *caplist_p || !*caplist); /* we *must* advance */

  /* move ahead in capability list string--or zero pointer if we hit end */
  *caplist_p = *caplist ? caplist : 0;

  return cap;    /* and return the capability (if any) */
}

/** Send a CAP \a subcmd list of capability changes to \a source_p.
 * If more than one line is necessary, each line before the last has
 * an added "*" parameter before that line's capability list.
 * @param[in] source_p Client receiving capability list.
 * @param[in] set Capabilities to show as set (with ack and sticky modifiers).
 * @param[in] rem Capabalities to show as removed (with no other modifier).
 * @param[in] subcmd Name of capability subcommand.
 */
static int
send_caplist(struct Client *source_p, unsigned int set,
             unsigned int rem, const char *subcmd)
{
  char capbuf[IRCD_BUFSIZE] = "", pfx[16];
  char cmdbuf[IRCD_BUFSIZE] = "";
  unsigned int i, loc, len, flags, pfx_len, clen;

  /* set up the buffer for the final LS message... */
  clen = snprintf(cmdbuf, sizeof(capbuf), ":%s CAP %s %s ", me.name,
                  source_p->name[0] ? source_p->name : "*", subcmd);

  for (i = 0, loc = 0; i < CAPAB_LIST_LEN; ++i)
  {
    flags = capab_list[i].flags;

    /*
     * This is a little bit subtle, but just involves applying de
     * Morgan's laws to the obvious check: We must display the
     * capability if (and only if) it is set in \a rem or \a set, or
     * if both are null and the capability is hidden.
     */
    if (!(rem && (rem & capab_list[i].cap)) &&
        !(set && (set & capab_list[i].cap)) &&
         (rem || set || (flags & CAPFL_HIDDEN)))
      continue;

    /* Build the prefix (space separator and any modifiers needed). */
    pfx_len = 0;

    if (loc)
      pfx[pfx_len++] = ' ';
    if (rem && (rem & capab_list[i].cap))
      pfx[pfx_len++] = '-';
    else
    {
      if (flags & CAPFL_PROTO)
        pfx[pfx_len++] = '~';
      if (flags & CAPFL_STICKY)
        pfx[pfx_len++] = '=';
    }

    pfx[pfx_len] = '\0';

    len = capab_list[i].namelen + pfx_len;    /* how much we'd add... */

    if (sizeof(capbuf) < (clen + loc + len + 15))
    {
      /* would add too much; must flush */
      sendto_one(source_p, "%s* :%s", cmdbuf, capbuf);
      capbuf[(loc = 0)] = '\0';    /* re-terminate the buffer... */
    }

    loc += snprintf(capbuf + loc, sizeof(capbuf) - loc,
                    "%s%s", pfx, capab_list[i].name);
  }

  sendto_one(source_p, "%s:%s", cmdbuf, capbuf);

  return 0;    /* convenience return */
}

static int
cap_ls(struct Client *source_p, const char *caplist)
{
  if (IsUnknown(source_p)) /* registration hasn't completed; suspend it... */
    source_p->localClient->registration |= REG_NEED_CAP;

  return send_caplist(source_p, 0, 0, "LS"); /* send list of capabilities */
}

static int
cap_req(struct Client *source_p, const char *caplist)
{
  const char *cl = caplist;
  struct capabilities *cap = NULL;
  unsigned int set = 0, rem = 0;
  unsigned int cs = source_p->localClient->cap_client; /* capability set */
  unsigned int as = source_p->localClient->cap_active; /* active set */
  int neg = 0;

  if (IsUnknown(source_p)) /* registration hasn't completed; suspend it... */
    source_p->localClient->registration |= REG_NEED_CAP;

  while (cl) { /* walk through the capabilities list... */
    if (!(cap = find_cap(&cl, &neg)) /* look up capability... */
        || (!neg && (cap->flags & CAPFL_PROHIBIT)) /* is it prohibited? */
        || (neg && (cap->flags & CAPFL_STICKY))) { /* is it sticky? */
      sendto_one(source_p, ":%s CAP %s NAK :%s", me.name,
                 source_p->name[0] ? source_p->name : "*", caplist);
      return 0; /* can't complete requested op... */
    }

    if (neg)
    {
      /* set or clear the capability... */
      rem |=  cap->cap;
      set &= ~cap->cap;
      cs  &= ~cap->cap;

      if (!(cap->flags & CAPFL_PROTO))
        as &= ~cap->cap;
    }
    else
    {
      rem &= ~cap->cap;
      set |=  cap->cap;
      cs  |=  cap->cap;

      if (!(cap->flags & CAPFL_PROTO))
        as |= cap->cap;
    }
  }

  /* Notify client of accepted changes and copy over results. */
  send_caplist(source_p, set, rem, "ACK");

  source_p->localClient->cap_client = cs;
  source_p->localClient->cap_active = as;

  return 0;
}

static int
cap_ack(struct Client *source_p, const char *caplist)
{
  const char *cl = caplist;
  struct capabilities *cap = NULL;
  int neg = 0;

  /*
   * Coming from the client, this generally indicates that the client
   * is using a new backwards-incompatible protocol feature.  As such,
   * it does not require further response from the server.
   */
  while (cl)
  {
    /* walk through the capabilities list... */
    if (!(cap = find_cap(&cl, &neg)) || /* look up capability... */
        (neg ? (source_p->localClient->cap_active & cap->cap) :
              !(source_p->localClient->cap_active & cap->cap))) /* uh... */
      continue;

    if (neg)    /* set or clear the active capability... */
      source_p->localClient->cap_active &= ~cap->cap;
    else
      source_p->localClient->cap_active |=  cap->cap;
  }

  return 0;
}

static int
cap_clear(struct Client *source_p, const char *caplist)
{
  struct capabilities *cap = NULL;
  unsigned int ii;
  unsigned int cleared = 0;

  for (ii = 0; ii < CAPAB_LIST_LEN; ++ii)
  {
    cap = &capab_list[ii];

    /* Only clear active non-sticky capabilities. */
    if (!(source_p->localClient->cap_active & cap->cap) || (cap->flags & CAPFL_STICKY))
      continue;

    cleared |= cap->cap;
    source_p->localClient->cap_client &= ~cap->cap;

    if (!(cap->flags & CAPFL_PROTO))
      source_p->localClient->cap_active &= ~cap->cap;
  }

  return send_caplist(source_p, 0, cleared, "ACK");
}

static int
cap_end(struct Client *source_p, const char *caplist)
{
  if (!IsUnknown(source_p))    /* registration has completed... */
    return 0;    /* so just ignore the message... */

  /* capability negotiation is now done... */
  source_p->localClient->registration &= ~REG_NEED_CAP;

  /* if client is now done... */
  if (!source_p->localClient->registration)
  {
    register_local_user(source_p);
    return 0;
  }

  return 0;    /* Can't do registration yet... */
}

static int
cap_list(struct Client *source_p, const char *caplist)
{
  /* Send the list of the client's capabilities */
  return send_caplist(source_p, source_p->localClient->cap_client, 0, "LIST");
}

static struct subcmd
{
  const char *cmd;
  int (*proc)(struct Client *, const char *);
} cmdlist[] = {
  { "ACK",   cap_ack   },
  { "CLEAR", cap_clear },
  { "END",   cap_end   },
  { "LIST",  cap_list  },
  { "LS",    cap_ls    },
  { "NAK",   NULL      },
  { "REQ",   cap_req   }
};

static int
subcmd_search(const char *cmd, const struct subcmd *elem)
{
  return strcasecmp(cmd, elem->cmd);
}

/** Handle a capability request or response from a client.
 * \param client_p Client that sent us the message.
 * \param source_p Original source of message.
 * \param parc     Number of arguments.
 * \param parv     Argument vector.
 */
static void
m_cap(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
  const char *subcmd = NULL, *caplist = NULL;
  struct subcmd *cmd = NULL;

  if (EmptyString(parv[1]))    /* a subcommand is required */
    return;

  subcmd = parv[1];

  if (parc > 2)    /* a capability list was provided */
    caplist = parv[2];

  /* find the subcommand handler */
  if (!(cmd = bsearch(subcmd, cmdlist,
                      sizeof(cmdlist) / sizeof(struct subcmd),
                      sizeof(struct subcmd), (bqcmp)subcmd_search)))
  {
    sendto_one(source_p, form_str(ERR_INVALIDCAPCMD), me.name,
               source_p->name[0] ? source_p->name : "*", subcmd);
    return;
  }

  /* then execute it... */
  if (cmd->proc)
    (cmd->proc)(source_p, caplist);
}

static struct Message cap_msgtab = {
  "CAP", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
  { m_cap, m_cap, m_ignore, m_ignore, m_cap, m_ignore }
};

static void
module_init(void)
{
  mod_add_cmd(&cap_msgtab);
}

static void
module_exit(void)
{
  mod_del_cmd(&cap_msgtab);
}

struct module module_entry = {
  .node    = { NULL, NULL, NULL },
  .name    = NULL,
  .version = "$Revision$",
  .handle  = NULL,
  .modinit = module_init,
  .modexit = module_exit,
  .flags   = 0
};
Revision:	1243
Committed:	Fri Sep 30 10:47:53 2011 UTC (14 years, 9 months ago) by michael
Content type:	text/x-csrc
Original Path:	*ircd-hybrid-8/modules/m_cap.c*
File size:	12216 byte(s)
Log Message:	- move content of msg.h, ircd_handler.h and handlers.h into parse.h and remove headers accordingly - killed common.h - remove m_killhost.c and m_flags.c from contrib/ - sort out unused header includes here and there
#	User	Rev	Content
1	michael	503	/*
2			* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3			*
4			* Copyright (C) 2004 Kevin L. Mitchell <klmitch@mit.edu>
5			* Copyright (C) 2006 Hybrid Development Team
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20			* USA
21			*
22			* $Id$
23			*/
24
25			/** @file
26			* @brief Capability negotiation commands
27			* @version $Id$
28			*/
29
30			#include "stdinc.h"
31			#include "client.h"
32			#include "hash.h"
33			#include "ircd.h"
34			#include "numeric.h"
35			#include "s_conf.h"
36			#include "s_user.h"
37			#include "s_serv.h"
38			#include "send.h"
39			#include "parse.h"
40			#include "modules.h"
41			#include "packet.h"
42			#include "irc_string.h"
43
44
45			#define CAPFL_HIDDEN 0x0001 /*< Do not advertize this capability /
46			#define CAPFL_PROHIBIT 0x0002 /*< Client may not set this capability /
47			#define CAPFL_PROTO 0x0004 /*< Cap must be acknowledged by client /
48			#define CAPFL_STICKY 0x0008 /*< Cap may not be cleared once set /
49
50			typedef int (bqcmp)(const void , const void *);
51
52			static struct capabilities
53			{
54			unsigned int cap;
55			unsigned int flags;
56			const char *name;
57			size_t namelen;
58			} capab_list[] = {
59			#define _CAP(cap, flags, name) \
60			{ (cap), (flags), (name), sizeof(name) - 1 }
61			_CAP(CAP_MULTI_PREFIX, 0, "multi-prefix")
62			#undef _CAP
63			};
64
65			#define CAPAB_LIST_LEN (sizeof(capab_list) / sizeof(struct capabilities))
66
67			static int
68			capab_sort(const struct capabilities cap1, const struct capabilities cap2)
69			{
70	michael	536	return strcasecmp(cap1->name, cap2->name);
71	michael	503	}
72
73			static int
74			capab_search(const char key, const struct capabilities cap)
75			{
76			const char *rb = cap->name;
77
78			while (ToLower(key) == ToLower(rb)) /* walk equivalent part of strings */
79			if (key++ == '\0') / hit the end, all right... */
80			return 0;
81			else /* OK, let's move on... */
82			rb++;
83
84	michael	872	/*
85			* If the character they differ on happens to be a space, and it happens
86	michael	503	* to be the same length as the capability name, then we've found a
87			* match; otherwise, return the difference of the two.
88			*/
89			return (IsSpace(key) && rb == '\0') ? 0 : (ToLower(key) - ToLower(rb));
90			}
91
92			static struct capabilities *
93			find_cap(const char *caplist_p, int neg_p)
94			{
95			static int inited = 0;
96			const char caplist = caplist_p;
97	michael	872	struct capabilities *cap = NULL;
98	michael	503
99			neg_p = 0; / clear negative flag... */
100
101			if (!inited)
102			{
103			/* First, let's sort the array... */
104			qsort(capab_list, CAPAB_LIST_LEN, sizeof(struct capabilities), (bqcmp)capab_sort);
105			++inited;
106			}
107
108			/* Next, find first non-whitespace character... */
109			while (caplist && IsSpace(caplist))
110			++caplist;
111
112			/* We are now at the beginning of an element of the list; is it negative? */
113	michael	872	if (*caplist == '-')
114			{
115	michael	503	++caplist; /* yes; step past the flag... */
116			neg_p = 1; / remember that it is negative... */
117			}
118
119			/* OK, now see if we can look up the capability... */
120	michael	872	if (*caplist)
121			{
122	michael	503	if (!(cap = bsearch(caplist, capab_list, CAPAB_LIST_LEN,
123			sizeof(struct capabilities),
124			(bqcmp)capab_search)))
125			{
126			/* Couldn't find the capability; advance to first whitespace character */
127			while (caplist && !IsSpace(caplist))
128			++caplist;
129			}
130			else
131			caplist += cap->namelen; /* advance to end of capability name */
132			}
133
134			assert(caplist != caplist_p \|\| !caplist); /* we must advance */
135
136			/* move ahead in capability list string--or zero pointer if we hit end */
137			caplist_p = caplist ? caplist : 0;
138
139			return cap; /* and return the capability (if any) */
140			}
141
142	michael	1230	/** Send a CAP \a subcmd list of capability changes to \a source_p.
143	michael	503	* If more than one line is necessary, each line before the last has
144			* an added "*" parameter before that line's capability list.
145	michael	1230	* @param[in] source_p Client receiving capability list.
146	michael	503	* @param[in] set Capabilities to show as set (with ack and sticky modifiers).
147			* @param[in] rem Capabalities to show as removed (with no other modifier).
148			* @param[in] subcmd Name of capability subcommand.
149			*/
150			static int
151	michael	1230	send_caplist(struct Client *source_p, unsigned int set,
152	michael	503	unsigned int rem, const char *subcmd)
153			{
154			char capbuf[IRCD_BUFSIZE] = "", pfx[16];
155			char cmdbuf[IRCD_BUFSIZE] = "";
156	michael	575	unsigned int i, loc, len, flags, pfx_len, clen;
157	michael	503
158			/* set up the buffer for the final LS message... */
159			clen = snprintf(cmdbuf, sizeof(capbuf), ":%s CAP %s %s ", me.name,
160	michael	1230	source_p->name[0] ? source_p->name : "*", subcmd);
161	michael	503
162			for (i = 0, loc = 0; i < CAPAB_LIST_LEN; ++i)
163			{
164			flags = capab_list[i].flags;
165
166			/*
167			* This is a little bit subtle, but just involves applying de
168			* Morgan's laws to the obvious check: We must display the
169			* capability if (and only if) it is set in \a rem or \a set, or
170			* if both are null and the capability is hidden.
171			*/
172			if (!(rem && (rem & capab_list[i].cap)) &&
173			!(set && (set & capab_list[i].cap)) &&
174			(rem \|\| set \|\| (flags & CAPFL_HIDDEN)))
175			continue;
176
177			/* Build the prefix (space separator and any modifiers needed). */
178			pfx_len = 0;
179
180			if (loc)
181			pfx[pfx_len++] = ' ';
182			if (rem && (rem & capab_list[i].cap))
183			pfx[pfx_len++] = '-';
184			else
185			{
186			if (flags & CAPFL_PROTO)
187			pfx[pfx_len++] = '~';
188			if (flags & CAPFL_STICKY)
189			pfx[pfx_len++] = '=';
190			}
191
192			pfx[pfx_len] = '\0';
193
194			len = capab_list[i].namelen + pfx_len; /* how much we'd add... */
195
196			if (sizeof(capbuf) < (clen + loc + len + 15))
197			{
198			/* would add too much; must flush */
199	michael	1230	sendto_one(source_p, "%s* :%s", cmdbuf, capbuf);
200	michael	503	capbuf[(loc = 0)] = '\0'; /* re-terminate the buffer... */
201			}
202
203			loc += snprintf(capbuf + loc, sizeof(capbuf) - loc,
204			"%s%s", pfx, capab_list[i].name);
205			}
206
207	michael	1230	sendto_one(source_p, "%s:%s", cmdbuf, capbuf);
208	michael	503
209			return 0; /* convenience return */
210			}
211
212			static int
213	michael	1230	cap_ls(struct Client source_p, const char caplist)
214	michael	503	{
215	michael	1230	if (IsUnknown(source_p)) /* registration hasn't completed; suspend it... */
216			source_p->localClient->registration \|= REG_NEED_CAP;
217	michael	503
218	michael	1230	return send_caplist(source_p, 0, 0, "LS"); /* send list of capabilities */
219	michael	503	}
220
221			static int
222	michael	1230	cap_req(struct Client source_p, const char caplist)
223	michael	503	{
224			const char *cl = caplist;
225	michael	872	struct capabilities *cap = NULL;
226	michael	503	unsigned int set = 0, rem = 0;
227	michael	1230	unsigned int cs = source_p->localClient->cap_client; /* capability set */
228			unsigned int as = source_p->localClient->cap_active; /* active set */
229	michael	872	int neg = 0;
230	michael	503
231	michael	1230	if (IsUnknown(source_p)) /* registration hasn't completed; suspend it... */
232			source_p->localClient->registration \|= REG_NEED_CAP;
233	michael	503
234			while (cl) { /* walk through the capabilities list... */
235			if (!(cap = find_cap(&cl, &neg)) /* look up capability... */
236			\|\| (!neg && (cap->flags & CAPFL_PROHIBIT)) /* is it prohibited? */
237			\|\| (neg && (cap->flags & CAPFL_STICKY))) { /* is it sticky? */
238	michael	1230	sendto_one(source_p, ":%s CAP %s NAK :%s", me.name,
239			source_p->name[0] ? source_p->name : "*", caplist);
240	michael	503	return 0; /* can't complete requested op... */
241			}
242
243			if (neg)
244			{
245			/* set or clear the capability... */
246			rem \|= cap->cap;
247			set &= ~cap->cap;
248			cs &= ~cap->cap;
249
250			if (!(cap->flags & CAPFL_PROTO))
251			as &= ~cap->cap;
252			}
253			else
254			{
255			rem &= ~cap->cap;
256			set \|= cap->cap;
257			cs \|= cap->cap;
258
259			if (!(cap->flags & CAPFL_PROTO))
260			as \|= cap->cap;
261			}
262			}
263
264			/* Notify client of accepted changes and copy over results. */
265	michael	1230	send_caplist(source_p, set, rem, "ACK");
266	michael	503
267	michael	1230	source_p->localClient->cap_client = cs;
268			source_p->localClient->cap_active = as;
269	michael	503
270			return 0;
271			}
272
273			static int
274	michael	1230	cap_ack(struct Client source_p, const char caplist)
275	michael	503	{
276			const char *cl = caplist;
277			struct capabilities *cap = NULL;
278	michael	872	int neg = 0;
279	michael	503
280			/*
281			* Coming from the client, this generally indicates that the client
282			* is using a new backwards-incompatible protocol feature. As such,
283			* it does not require further response from the server.
284			*/
285			while (cl)
286			{
287			/* walk through the capabilities list... */
288			if (!(cap = find_cap(&cl, &neg)) \|\| /* look up capability... */
289	michael	1230	(neg ? (source_p->localClient->cap_active & cap->cap) :
290			!(source_p->localClient->cap_active & cap->cap))) /* uh... */
291	michael	503	continue;
292
293			if (neg) /* set or clear the active capability... */
294	michael	1230	source_p->localClient->cap_active &= ~cap->cap;
295	michael	503	else
296	michael	1230	source_p->localClient->cap_active \|= cap->cap;
297	michael	503	}
298
299			return 0;
300			}
301
302			static int
303	michael	1230	cap_clear(struct Client source_p, const char caplist)
304	michael	503	{
305	michael	872	struct capabilities *cap = NULL;
306	michael	503	unsigned int ii;
307			unsigned int cleared = 0;
308
309			for (ii = 0; ii < CAPAB_LIST_LEN; ++ii)
310			{
311			cap = &capab_list[ii];
312
313			/* Only clear active non-sticky capabilities. */
314	michael	1230	if (!(source_p->localClient->cap_active & cap->cap) \|\| (cap->flags & CAPFL_STICKY))
315	michael	503	continue;
316
317			cleared \|= cap->cap;
318	michael	1230	source_p->localClient->cap_client &= ~cap->cap;
319	michael	503
320			if (!(cap->flags & CAPFL_PROTO))
321	michael	1230	source_p->localClient->cap_active &= ~cap->cap;
322	michael	503	}
323
324	michael	1230	return send_caplist(source_p, 0, cleared, "ACK");
325	michael	503	}
326
327			static int
328	michael	1230	cap_end(struct Client source_p, const char caplist)
329	michael	503	{
330	michael	1230	if (!IsUnknown(source_p)) /* registration has completed... */
331	michael	503	return 0; /* so just ignore the message... */
332
333			/* capability negotiation is now done... */
334	michael	1230	source_p->localClient->registration &= ~REG_NEED_CAP;
335	michael	503
336			/* if client is now done... */
337	michael	1230	if (!source_p->localClient->registration)
338	michael	503	{
339	michael	1230	register_local_user(source_p);
340	michael	503	return 0;
341			}
342
343			return 0; /* Can't do registration yet... */
344			}
345
346			static int
347	michael	1230	cap_list(struct Client source_p, const char caplist)
348	michael	503	{
349			/* Send the list of the client's capabilities */
350	michael	1230	return send_caplist(source_p, source_p->localClient->cap_client, 0, "LIST");
351	michael	503	}
352
353			static struct subcmd
354			{
355	michael	575	const char *cmd;
356	michael	1230	int (proc)(struct Client , const char *);
357	michael	503	} cmdlist[] = {
358			{ "ACK", cap_ack },
359			{ "CLEAR", cap_clear },
360			{ "END", cap_end },
361			{ "LIST", cap_list },
362			{ "LS", cap_ls },
363	michael	575	{ "NAK", NULL },
364	michael	503	{ "REQ", cap_req }
365			};
366
367			static int
368			subcmd_search(const char cmd, const struct subcmd elem)
369			{
370	michael	536	return strcasecmp(cmd, elem->cmd);
371	michael	503	}
372
373			/** Handle a capability request or response from a client.
374	michael	1230	* \param client_p Client that sent us the message.
375			* \param source_p Original source of message.
376			* \param parc Number of arguments.
377			* \param parv Argument vector.
378	michael	503	*/
379			static void
380	michael	1230	m_cap(struct Client client_p, struct Client source_p, int parc, char *parv[])
381	michael	503	{
382	michael	1222	const char subcmd = NULL, caplist = NULL;
383	michael	503	struct subcmd *cmd = NULL;
384
385	michael	1178	if (EmptyString(parv[1])) /* a subcommand is required */
386	michael	503	return;
387
388			subcmd = parv[1];
389
390			if (parc > 2) /* a capability list was provided */
391			caplist = parv[2];
392
393			/* find the subcommand handler */
394			if (!(cmd = bsearch(subcmd, cmdlist,
395			sizeof(cmdlist) / sizeof(struct subcmd),
396			sizeof(struct subcmd), (bqcmp)subcmd_search)))
397			{
398	michael	1230	sendto_one(source_p, form_str(ERR_INVALIDCAPCMD), me.name,
399			source_p->name[0] ? source_p->name : "*", subcmd);
400	michael	503	return;
401			}
402
403			/* then execute it... */
404			if (cmd->proc)
405	michael	1230	(cmd->proc)(source_p, caplist);
406	michael	503	}
407	michael	1230
408			static struct Message cap_msgtab = {
409			"CAP", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
410			{ m_cap, m_cap, m_ignore, m_ignore, m_cap, m_ignore }
411			};
412
413			static void
414			module_init(void)
415			{
416			mod_add_cmd(&cap_msgtab);
417			}
418
419			static void
420			module_exit(void)
421			{
422			mod_del_cmd(&cap_msgtab);
423			}
424
425			struct module module_entry = {
426			.node = { NULL, NULL, NULL },
427			.name = NULL,
428			.version = "$Revision$",
429			.handle = NULL,
430			.modinit = module_init,
431			.modexit = module_exit,
432			.flags = 0
433			};