ermyth/src/channels.C

/*
 * channels.C: Channel event and state tracking
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)           
 */

static char const rcsid[] = "$Id";

#include "atheme.h"
#include <account/mychan.h>

dictionary_tree_t *chanlist;

static BlockHeap *chan_heap;
static BlockHeap *chanuser_heap;
static BlockHeap *chanban_heap;

/*
 * init_channels()
 *
 * Initializes the channel-related heaps and DTree structures.
 *
 * Inputs:
 *     - nothing
 *
 * Outputs:
 *     - nothing
 *
 * Side Effects:
 *     - if the heaps or DTrees fail to initialize, the program will abort.
 */
void
init_channels (void)
{
  chan_heap = BlockHeapCreate (sizeof (channel_t), HEAP_CHANNEL);
  chanuser_heap = BlockHeapCreate (sizeof (chanuser_t), HEAP_CHANUSER);
  chanban_heap = BlockHeapCreate (sizeof (chanban_t), HEAP_CHANUSER);

  if (chan_heap == NULL || chanuser_heap == NULL || chanban_heap == NULL)
    {
      slog (LG_INFO, "init_channels(): block allocator failure.");
      exit (EXIT_FAILURE);
    }

  chanlist = dictionary_create ("channel", HASH_CHANNEL, irccasecmp);
}

/*
 * channel_add(const char *name, unsigned int ts, server_t *creator)
 *
 * Channel object factory.
 *
 * Inputs:
 *     - channel name
 *     - timestamp of channel creation
 *     - server that is creating the channel
 *
 * Outputs:
 *     - on success, a channel object
 *     - on failure, NULL
 *
 * Side Effects:
 *     - the channel is automatically inserted into the channel DTree
 *     - if the creator is not me.me:
 *       - channel_add hook is called
 *       - all services are joined if this is the snoop channel
 *     - if the creator is me.me these actions must be performed by the
 *       caller (i.e. join()) after joining the service
 */
channel_t *
channel_add (const char *name, unsigned int ts, server_t *creator)
{
  channel_t *c;
  mychan_t *mc;

  if (*name != '#')
    {
      slog (LG_DEBUG, "channel_add(): got non #channel: %s", name);
      return NULL;
    }

  c = channel_find (name);

  if (c)
    {
      slog (LG_DEBUG, "channel_add(): channel already exists: %s", name);
      return c;
    }

  slog (LG_DEBUG, "channel_add(): %s by %s", name, creator->name);

  c = static_cast<channel_t *> (BlockHeapAlloc (chan_heap));

  c->name = sstrdup (name);
  c->ts = ts;

  c->topic = NULL;
  c->topic_setter = NULL;

  c->bans.head = NULL;
  c->bans.tail = NULL;
  c->bans.count = 0;

  if ((mc = mychan_find (c->name)))
    mc->chan = c;

  dictionary_add (chanlist, c->name, c);

  cnt.chan++;

  if (creator != me.me)
    {
      hook_call_event ("channel_add", c);

      if (config_options.chan != NULL && !irccasecmp (config_options.chan, name))
        joinall (config_options.chan);
    }

  return c;
}

/*
 * channel_delete(channel_t *c)
 *
 * Destroys a channel object and its children member objects.
 *
 * Inputs:
 *     - channel object to destroy
 *
 * Outputs:
 *     - nothing
 *
 * Side Effects:
 *     - channel_delete hook is called
 *     - a channel and all attached structures are destroyed
 *     - no protocol messages are sent for any remaining members
 */
void
channel_delete (channel_t *c)
{
  mychan_t *mc;
  node_t *n, *tn;
  chanuser_t *cu;

  return_if_fail (c != NULL);

  slog (LG_DEBUG, "channel_delete(): %s", c->name);

  modestack_finalize_channel (c);

  /* If this is called from uplink_close(), there may still be services
   * in the channel. Remove them. Calling chanuser_delete() could lead
   * to a recursive call, so don't do that.
   * -- jilles */
  LIST_FOREACH_SAFE (n, tn, c->members.head)
  {
    cu = static_cast<chanuser_t *> (n->data);
    soft_assert (is_internal_client (cu->user) && !me.connected);
    node_del (&cu->cnode, &c->members);
    node_del (&cu->unode, &cu->user->channels);
    BlockHeapFree (chanuser_heap, cu);
    cnt.chanuser--;
  }
  c->nummembers = 0;

  hook_call_event ("channel_delete", c);

  dictionary_delete (chanlist, c->name);

  if ((mc = mychan_find (c->name)))
    mc->chan = NULL;

  clear_simple_modes (c);
  chanban_clear (c);

  free (c->name);
  if (c->topic != NULL)
    free (c->topic);
  if (c->topic_setter != NULL)
    free (c->topic_setter);

  BlockHeapFree (chan_heap, c);

  cnt.chan--;
}

/*
 * channel_find(const char *name)
 *
 * Looks up a channel object.
 *
 * Inputs:
 *     - name of channel to look up
 *
 * Outputs:
 *     - on success, the channel object
 *     - on failure, NULL
 *
 * Side Effects:
 *     - none
 */
channel_t *
channel_find (const char *name)
{
  return static_cast<channel_t *> (dictionary_retrieve (chanlist, name));
}

/*
 * chanban_add(channel_t *chan, const char *mask, int type)
 *
 * Channel ban factory.
 *
 * Inputs:
 *     - channel that the ban belongs to
 *     - banmask
 *     - type of ban, e.g. 'b' or 'e'
 *
 * Outputs:
 *     - on success, a new channel ban object
 *     - on failure, NULL
 *
 * Side Effects:
 *     - the created channel ban object is added to the channel automatically.
 */
chanban_t *
chanban_add (channel_t *chan, const char *mask, int type)
{
  chanban_t *c;
  node_t *n;

  if (mask == NULL)
    {
      slog (LG_ERROR, "chanban_add(): NULL +%c mask", type);
      return NULL;
    }
  /* this would break protocol and/or cause crashes */
  if (*mask == '\0' || *mask == ':' || strchr (mask, ' '))
    {
      slog (LG_ERROR, "chanban_add(): trying to add invalid +%c %s to channel %s", type, mask, chan->name);
      return NULL;
    }

  c = chanban_find (chan, mask, type);

  if (c)
    {
      slog (LG_DEBUG, "chanban_add(): channel ban %s:%s already exists", chan->name, c->mask);
      return NULL;
    }

  slog (LG_DEBUG, "chanban_add(): %s +%c %s", chan->name, type, mask);

  n = node_create ();
  c = static_cast<chanban_t *> (BlockHeapAlloc (chanban_heap));

  c->chan = chan;
  c->mask = sstrdup (mask);
  c->type = type;

  node_add (c, n, &chan->bans);

  return c;
}

/*
 * chanban_delete(chanban_t *c)
 *
 * Destroys a channel ban.
 *
 * Inputs:
 *     - channel ban object to destroy
 *
 * Outputs:
 *     - nothing
 *
 * Side Effects:
 *     - the channel ban is automatically removed from the channel that owned it
 */
void
chanban_delete (chanban_t *c)
{
  node_t *n;

  if (!c)
    {
      slog (LG_DEBUG, "chanban_delete(): called for nonexistant ban");
      return;
    }

  n = node_find (c, &c->chan->bans);
  node_del (n, &c->chan->bans);
  node_free (n);

  free (c->mask);
  BlockHeapFree (chanban_heap, c);
}

/*
 * chanban_find(channel_t *chan, const char *mask, int type)
 *
 * Looks up a channel ban.
 *
 * Inputs:
 *     - channel that the ban is supposedly on
 *     - mask that is being looked for
 *     - type of ban that is being looked for
 *
 * Outputs:
 *     - on success, returns the channel ban object requested
 *     - on failure, returns NULL
 *
 * Side Effects:
 *     - none
 */
chanban_t *
chanban_find (channel_t *chan, const char *mask, int type)
{
  chanban_t *cb;
  node_t *n;

  LIST_FOREACH (n, chan->bans.head)
  {
    cb = static_cast<chanban_t *> (n->data);

    if (cb->type == type && !irccasecmp (cb->mask, mask))
      return cb;
  }

  return NULL;
}

/*
 * chanban_clear(channel_t *chan)
 *
 * Destroys all channel bans attached to a channel.
 *
 * Inputs:
 *     - channel to clear banlist on
 *
 * Outputs:
 *     - nothing
 *
 * Side Effects:
 *     - the banlist on the channel is cleared
 *     - no protocol messages are sent
 */
void
chanban_clear (channel_t *chan)
{
  node_t *n, *tn;

  LIST_FOREACH_SAFE (n, tn, chan->bans.head)
  {
    /* inefficient but avoids code duplication -- jilles */
    chanban_delete (static_cast<chanban_t *> (n->data));
  }
}

/*
 * chanuser_add(channel_t *chan, const char *nick)
 *
 * Channel user factory.
 *
 * Inputs:
 *     - channel that the user should belong to
 *     - nick/UID with any appropriate prefixes (e.g. ~, &, @, %, +)
 *       (if the user has a UID it must be used)
 *
 * Outputs:
 *     - on success, a new channel user object
 *     - on failure (NULL channel, or user kicked by channel_join hook), NULL
 *
 * Side Effects:
 *     - the channel user object is automatically associated to its parents
 *     - channel_join hook is called
 */

/*
 * Rewritten 06/23/05 by nenolod:
 *
 * Iterate through the list of prefix characters we know about.
 * Continue to do so until all prefixes are covered. Then add the
 * nick to the channel, with the privs he has acquired thus far.
 *
 * Once, and only once we have done that do we start in on checking
 * privileges. Otherwise we have a very inefficient way of doing
 * things. It worked fine for shrike, but the old code was restricted
 * to handling only @, @+ and + as prefixes.
 */
chanuser_t *
chanuser_add (channel_t *chan, const char *nick)
{
  user_t *u;
  chanuser_t *cu, *tcu;
  unsigned int flags = 0;
  int i = 0;
  hook_channel_joinpart_t hdata;

  if (chan == NULL)
    return NULL;

  if (*chan->name != '#')
    {
      slog (LG_DEBUG, "chanuser_add(): got non #channel: %s", chan->name);
      return NULL;
    }

  while (*nick != '\0')
    {
      for (i = 0; prefix_mode_list[i].mode; i++)
        if (*nick == prefix_mode_list[i].mode)
          {
            flags |= prefix_mode_list[i].value;
            break;
          }
      if (!prefix_mode_list[i].mode)
        break;
      nick++;
    }

  u = user_find (nick);
  if (u == NULL)
    {
      slog (LG_DEBUG, "chanuser_add(): nonexist user: %s", nick);
      return NULL;
    }

  tcu = chanuser_find (chan, u);
  if (tcu != NULL)
    {
      slog (LG_DEBUG, "chanuser_add(): user is already present: %s -> %s", chan->name, u->nick);

      /* could be an OPME or other desyncher... */
      tcu->modes |= flags;

      return tcu;
    }

  slog (LG_DEBUG, "chanuser_add(): %s -> %s", chan->name, u->nick);

  cu = static_cast<chanuser_t *> (BlockHeapAlloc (chanuser_heap));

  cu->chan = chan;
  cu->user = u;
  cu->modes |= flags;

  chan->nummembers++;

  node_add (cu, &cu->cnode, &chan->members);
  node_add (cu, &cu->unode, &u->channels);

  cnt.chanuser++;

  hdata.cu = cu;
  hook_call_event ("channel_join", &hdata);

  /* Return NULL if a hook function kicked the user out */
  return hdata.cu;
}

/*
 * chanuser_delete(channel_t *chan, user_t *user)
 *
 * Destroys a channel user object.
 *
 * Inputs:
 *     - channel the user is on
 *     - the user itself
 *
 * Outputs:
 *     - nothing
 *
 * Side Effects:
 *     if the user is on the channel:
 *     - a channel user object is removed from the
 *       channel's userlist and the user's channellist.
 *     - channel_part hook is called
 *     - if this empties the channel and the channel is not set permanent
 *       (ircd->perm_mode), channel_delete() is called (q.v.)
 */
void
chanuser_delete (channel_t *chan, user_t *user)
{
  chanuser_t *cu;
  hook_channel_joinpart_t hdata;

  if (!chan)
    {
      slog (LG_DEBUG, "chanuser_delete(): called with NULL chan");
      return;
    }

  if (!user)
    {
      slog (LG_DEBUG, "chanuser_delete(): called with NULL user");
      return;
    }

  cu = chanuser_find (chan, user);
  if (cu == NULL)
    return;

  /* this is called BEFORE we remove the user */
  hdata.cu = cu;
  hook_call_event ("channel_part", &hdata);

  slog (LG_DEBUG, "chanuser_delete(): %s -> %s (%d)", cu->chan->name, cu->user->nick, cu->chan->nummembers - 1);

  node_del (&cu->cnode, &chan->members);
  node_del (&cu->unode, &user->channels);

  BlockHeapFree (chanuser_heap, cu);

  chan->nummembers--;
  cnt.chanuser--;

  if (chan->nummembers == 0 && !(chan->modes & ircd->perm_mode))
    {
      /* empty channels die */
      slog (LG_DEBUG, "chanuser_delete(): `%s' is empty, removing", chan->name);

      channel_delete (chan);
    }
}

/*
 * chanuser_find(channel_t *chan, user_t *user)
 *
 * Looks up a channel user object.
 *
 * Inputs:
 *     - channel object that the user is on
 *     - target user object
 *
 * Outputs:
 *     - on success, a channel user object
 *     - on failure, NULL
 *
 * Side Effects:
 *     - none
 */
chanuser_t *
chanuser_find (channel_t *chan, user_t *user)
{
  node_t *n;
  chanuser_t *cu;

  if ((!chan) || (!user))
    return NULL;

  /* choose shortest list to search -- jilles */
  if (LIST_LENGTH (&user->channels) < LIST_LENGTH (&chan->members))
    {
      LIST_FOREACH (n, user->channels.head)
      {
        cu = (chanuser_t *) n->data;

        if (cu->chan == chan)
          return cu;
      }
    }
  else
    {
      LIST_FOREACH (n, chan->members.head)
      {
        cu = (chanuser_t *) n->data;

        if (cu->user == user)
          return cu;
      }
    }

  return NULL;
}

/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
 * vim:ts=8
 * vim:sw=8
 * vim:noexpandtab
 */
Revision:	1.2
Committed:	Sat Jul 21 01:29:10 2007 UTC (19 years, 1 month ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+1 -1 lines
Log Message:	- moved to new documentation system - fixed small build error
#	User	Rev	Content
1	pippijn	1.1	/*
2			* channels.C: Channel event and state tracking
3	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
4	pippijn	1.1	*
5			* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
6			*/
7
8			static char const rcsid[] = "$Id";
9
10			#include "atheme.h"
11			#include <account/mychan.h>
12
13			dictionary_tree_t *chanlist;
14
15			static BlockHeap *chan_heap;
16			static BlockHeap *chanuser_heap;
17			static BlockHeap *chanban_heap;
18
19			/*
20			* init_channels()
21			*
22			* Initializes the channel-related heaps and DTree structures.
23			*
24			* Inputs:
25			* - nothing
26			*
27			* Outputs:
28			* - nothing
29			*
30			* Side Effects:
31			* - if the heaps or DTrees fail to initialize, the program will abort.
32			*/
33			void
34			init_channels (void)
35			{
36			chan_heap = BlockHeapCreate (sizeof (channel_t), HEAP_CHANNEL);
37			chanuser_heap = BlockHeapCreate (sizeof (chanuser_t), HEAP_CHANUSER);
38			chanban_heap = BlockHeapCreate (sizeof (chanban_t), HEAP_CHANUSER);
39
40			if (chan_heap == NULL \|\| chanuser_heap == NULL \|\| chanban_heap == NULL)
41			{
42			slog (LG_INFO, "init_channels(): block allocator failure.");
43			exit (EXIT_FAILURE);
44			}
45
46			chanlist = dictionary_create ("channel", HASH_CHANNEL, irccasecmp);
47			}
48
49			/*
50			* channel_add(const char name, unsigned int ts, server_t creator)
51			*
52			* Channel object factory.
53			*
54			* Inputs:
55			* - channel name
56			* - timestamp of channel creation
57			* - server that is creating the channel
58			*
59			* Outputs:
60			* - on success, a channel object
61			* - on failure, NULL
62			*
63			* Side Effects:
64			* - the channel is automatically inserted into the channel DTree
65			* - if the creator is not me.me:
66			* - channel_add hook is called
67			* - all services are joined if this is the snoop channel
68			* - if the creator is me.me these actions must be performed by the
69			* caller (i.e. join()) after joining the service
70			*/
71			channel_t *
72			channel_add (const char name, unsigned int ts, server_t creator)
73			{
74			channel_t *c;
75			mychan_t *mc;
76
77			if (*name != '#')
78			{
79			slog (LG_DEBUG, "channel_add(): got non #channel: %s", name);
80			return NULL;
81			}
82
83			c = channel_find (name);
84
85			if (c)
86			{
87			slog (LG_DEBUG, "channel_add(): channel already exists: %s", name);
88			return c;
89			}
90
91			slog (LG_DEBUG, "channel_add(): %s by %s", name, creator->name);
92
93			c = static_cast<channel_t *> (BlockHeapAlloc (chan_heap));
94
95			c->name = sstrdup (name);
96			c->ts = ts;
97
98			c->topic = NULL;
99			c->topic_setter = NULL;
100
101			c->bans.head = NULL;
102			c->bans.tail = NULL;
103			c->bans.count = 0;
104
105			if ((mc = mychan_find (c->name)))
106			mc->chan = c;
107
108			dictionary_add (chanlist, c->name, c);
109
110			cnt.chan++;
111
112			if (creator != me.me)
113			{
114			hook_call_event ("channel_add", c);
115
116			if (config_options.chan != NULL && !irccasecmp (config_options.chan, name))
117			joinall (config_options.chan);
118			}
119
120			return c;
121			}
122
123			/*
124			* channel_delete(channel_t *c)
125			*
126			* Destroys a channel object and its children member objects.
127			*
128			* Inputs:
129			* - channel object to destroy
130			*
131			* Outputs:
132			* - nothing
133			*
134			* Side Effects:
135			* - channel_delete hook is called
136			* - a channel and all attached structures are destroyed
137			* - no protocol messages are sent for any remaining members
138			*/
139			void
140			channel_delete (channel_t *c)
141			{
142			mychan_t *mc;
143			node_t n, tn;
144			chanuser_t *cu;
145
146			return_if_fail (c != NULL);
147
148			slog (LG_DEBUG, "channel_delete(): %s", c->name);
149
150			modestack_finalize_channel (c);
151
152			/* If this is called from uplink_close(), there may still be services
153			* in the channel. Remove them. Calling chanuser_delete() could lead
154			* to a recursive call, so don't do that.
155			* -- jilles */
156			LIST_FOREACH_SAFE (n, tn, c->members.head)
157			{
158			cu = static_cast<chanuser_t *> (n->data);
159			soft_assert (is_internal_client (cu->user) && !me.connected);
160			node_del (&cu->cnode, &c->members);
161			node_del (&cu->unode, &cu->user->channels);
162			BlockHeapFree (chanuser_heap, cu);
163			cnt.chanuser--;
164			}
165			c->nummembers = 0;
166
167			hook_call_event ("channel_delete", c);
168
169			dictionary_delete (chanlist, c->name);
170
171			if ((mc = mychan_find (c->name)))
172			mc->chan = NULL;
173
174			clear_simple_modes (c);
175			chanban_clear (c);
176
177			free (c->name);
178			if (c->topic != NULL)
179			free (c->topic);
180			if (c->topic_setter != NULL)
181			free (c->topic_setter);
182
183			BlockHeapFree (chan_heap, c);
184
185			cnt.chan--;
186			}
187
188			/*
189			* channel_find(const char *name)
190			*
191			* Looks up a channel object.
192			*
193			* Inputs:
194			* - name of channel to look up
195			*
196			* Outputs:
197			* - on success, the channel object
198			* - on failure, NULL
199			*
200			* Side Effects:
201			* - none
202			*/
203			channel_t *
204			channel_find (const char *name)
205			{
206			return static_cast<channel_t *> (dictionary_retrieve (chanlist, name));
207			}
208
209			/*
210			* chanban_add(channel_t chan, const char mask, int type)
211			*
212			* Channel ban factory.
213			*
214			* Inputs:
215			* - channel that the ban belongs to
216			* - banmask
217			* - type of ban, e.g. 'b' or 'e'
218			*
219			* Outputs:
220			* - on success, a new channel ban object
221			* - on failure, NULL
222			*
223			* Side Effects:
224			* - the created channel ban object is added to the channel automatically.
225			*/
226			chanban_t *
227			chanban_add (channel_t chan, const char mask, int type)
228			{
229			chanban_t *c;
230			node_t *n;
231
232			if (mask == NULL)
233			{
234			slog (LG_ERROR, "chanban_add(): NULL +%c mask", type);
235			return NULL;
236			}
237			/* this would break protocol and/or cause crashes */
238			if (mask == '\0' \|\| mask == ':' \|\| strchr (mask, ' '))
239			{
240			slog (LG_ERROR, "chanban_add(): trying to add invalid +%c %s to channel %s", type, mask, chan->name);
241			return NULL;
242			}
243
244			c = chanban_find (chan, mask, type);
245
246			if (c)
247			{
248			slog (LG_DEBUG, "chanban_add(): channel ban %s:%s already exists", chan->name, c->mask);
249			return NULL;
250			}
251
252			slog (LG_DEBUG, "chanban_add(): %s +%c %s", chan->name, type, mask);
253
254			n = node_create ();
255			c = static_cast<chanban_t *> (BlockHeapAlloc (chanban_heap));
256
257			c->chan = chan;
258			c->mask = sstrdup (mask);
259			c->type = type;
260
261			node_add (c, n, &chan->bans);
262
263			return c;
264			}
265
266			/*
267			* chanban_delete(chanban_t *c)
268			*
269			* Destroys a channel ban.
270			*
271			* Inputs:
272			* - channel ban object to destroy
273			*
274			* Outputs:
275			* - nothing
276			*
277			* Side Effects:
278			* - the channel ban is automatically removed from the channel that owned it
279			*/
280			void
281			chanban_delete (chanban_t *c)
282			{
283			node_t *n;
284
285			if (!c)
286			{
287			slog (LG_DEBUG, "chanban_delete(): called for nonexistant ban");
288			return;
289			}
290
291			n = node_find (c, &c->chan->bans);
292			node_del (n, &c->chan->bans);
293			node_free (n);
294
295			free (c->mask);
296			BlockHeapFree (chanban_heap, c);
297			}
298
299			/*
300			* chanban_find(channel_t chan, const char mask, int type)
301			*
302			* Looks up a channel ban.
303			*
304			* Inputs:
305			* - channel that the ban is supposedly on
306			* - mask that is being looked for
307			* - type of ban that is being looked for
308			*
309			* Outputs:
310			* - on success, returns the channel ban object requested
311			* - on failure, returns NULL
312			*
313			* Side Effects:
314			* - none
315			*/
316			chanban_t *
317			chanban_find (channel_t chan, const char mask, int type)
318			{
319			chanban_t *cb;
320			node_t *n;
321
322			LIST_FOREACH (n, chan->bans.head)
323			{
324			cb = static_cast<chanban_t *> (n->data);
325
326			if (cb->type == type && !irccasecmp (cb->mask, mask))
327			return cb;
328			}
329
330			return NULL;
331			}
332
333			/*
334			* chanban_clear(channel_t *chan)
335			*
336			* Destroys all channel bans attached to a channel.
337			*
338			* Inputs:
339			* - channel to clear banlist on
340			*
341			* Outputs:
342			* - nothing
343			*
344			* Side Effects:
345			* - the banlist on the channel is cleared
346			* - no protocol messages are sent
347			*/
348			void
349			chanban_clear (channel_t *chan)
350			{
351			node_t n, tn;
352
353			LIST_FOREACH_SAFE (n, tn, chan->bans.head)
354			{
355			/* inefficient but avoids code duplication -- jilles */
356			chanban_delete (static_cast<chanban_t *> (n->data));
357			}
358			}
359
360			/*
361			* chanuser_add(channel_t chan, const char nick)
362			*
363			* Channel user factory.
364			*
365			* Inputs:
366			* - channel that the user should belong to
367			* - nick/UID with any appropriate prefixes (e.g. ~, &, @, %, +)
368			* (if the user has a UID it must be used)
369			*
370			* Outputs:
371			* - on success, a new channel user object
372			* - on failure (NULL channel, or user kicked by channel_join hook), NULL
373			*
374			* Side Effects:
375			* - the channel user object is automatically associated to its parents
376			* - channel_join hook is called
377			*/
378
379			/*
380			* Rewritten 06/23/05 by nenolod:
381			*
382			* Iterate through the list of prefix characters we know about.
383			* Continue to do so until all prefixes are covered. Then add the
384			* nick to the channel, with the privs he has acquired thus far.
385			*
386			* Once, and only once we have done that do we start in on checking
387			* privileges. Otherwise we have a very inefficient way of doing
388			* things. It worked fine for shrike, but the old code was restricted
389			* to handling only @, @+ and + as prefixes.
390			*/
391			chanuser_t *
392			chanuser_add (channel_t chan, const char nick)
393			{
394			user_t *u;
395			chanuser_t cu, tcu;
396			unsigned int flags = 0;
397			int i = 0;
398			hook_channel_joinpart_t hdata;
399
400			if (chan == NULL)
401			return NULL;
402
403			if (*chan->name != '#')
404			{
405			slog (LG_DEBUG, "chanuser_add(): got non #channel: %s", chan->name);
406			return NULL;
407			}
408
409			while (*nick != '\0')
410			{
411			for (i = 0; prefix_mode_list[i].mode; i++)
412			if (*nick == prefix_mode_list[i].mode)
413			{
414			flags \|= prefix_mode_list[i].value;
415			break;
416			}
417			if (!prefix_mode_list[i].mode)
418			break;
419			nick++;
420			}
421
422			u = user_find (nick);
423			if (u == NULL)
424			{
425			slog (LG_DEBUG, "chanuser_add(): nonexist user: %s", nick);
426			return NULL;
427			}
428
429			tcu = chanuser_find (chan, u);
430			if (tcu != NULL)
431			{
432			slog (LG_DEBUG, "chanuser_add(): user is already present: %s -> %s", chan->name, u->nick);
433
434			/* could be an OPME or other desyncher... */
435			tcu->modes \|= flags;
436
437			return tcu;
438			}
439
440			slog (LG_DEBUG, "chanuser_add(): %s -> %s", chan->name, u->nick);
441
442			cu = static_cast<chanuser_t *> (BlockHeapAlloc (chanuser_heap));
443
444			cu->chan = chan;
445			cu->user = u;
446			cu->modes \|= flags;
447
448			chan->nummembers++;
449
450			node_add (cu, &cu->cnode, &chan->members);
451			node_add (cu, &cu->unode, &u->channels);
452
453			cnt.chanuser++;
454
455			hdata.cu = cu;
456			hook_call_event ("channel_join", &hdata);
457
458			/* Return NULL if a hook function kicked the user out */
459			return hdata.cu;
460			}
461
462			/*
463			* chanuser_delete(channel_t chan, user_t user)
464			*
465			* Destroys a channel user object.
466			*
467			* Inputs:
468			* - channel the user is on
469			* - the user itself
470			*
471			* Outputs:
472			* - nothing
473			*
474			* Side Effects:
475			* if the user is on the channel:
476			* - a channel user object is removed from the
477			* channel's userlist and the user's channellist.
478			* - channel_part hook is called
479			* - if this empties the channel and the channel is not set permanent
480			* (ircd->perm_mode), channel_delete() is called (q.v.)
481			*/
482			void
483			chanuser_delete (channel_t chan, user_t user)
484			{
485			chanuser_t *cu;
486			hook_channel_joinpart_t hdata;
487
488			if (!chan)
489			{
490			slog (LG_DEBUG, "chanuser_delete(): called with NULL chan");
491			return;
492			}
493
494			if (!user)
495			{
496			slog (LG_DEBUG, "chanuser_delete(): called with NULL user");
497			return;
498			}
499
500			cu = chanuser_find (chan, user);
501			if (cu == NULL)
502			return;
503
504			/* this is called BEFORE we remove the user */
505			hdata.cu = cu;
506			hook_call_event ("channel_part", &hdata);
507
508			slog (LG_DEBUG, "chanuser_delete(): %s -> %s (%d)", cu->chan->name, cu->user->nick, cu->chan->nummembers - 1);
509
510			node_del (&cu->cnode, &chan->members);
511			node_del (&cu->unode, &user->channels);
512
513			BlockHeapFree (chanuser_heap, cu);
514
515			chan->nummembers--;
516			cnt.chanuser--;
517
518			if (chan->nummembers == 0 && !(chan->modes & ircd->perm_mode))
519			{
520			/* empty channels die */
521			slog (LG_DEBUG, "chanuser_delete(): `%s' is empty, removing", chan->name);
522
523			channel_delete (chan);
524			}
525			}
526
527			/*
528			* chanuser_find(channel_t chan, user_t user)
529			*
530			* Looks up a channel user object.
531			*
532			* Inputs:
533			* - channel object that the user is on
534			* - target user object
535			*
536			* Outputs:
537			* - on success, a channel user object
538			* - on failure, NULL
539			*
540			* Side Effects:
541			* - none
542			*/
543			chanuser_t *
544			chanuser_find (channel_t chan, user_t user)
545			{
546			node_t *n;
547			chanuser_t *cu;
548
549			if ((!chan) \|\| (!user))
550			return NULL;
551
552			/* choose shortest list to search -- jilles */
553			if (LIST_LENGTH (&user->channels) < LIST_LENGTH (&chan->members))
554			{
555			LIST_FOREACH (n, user->channels.head)
556			{
557			cu = (chanuser_t *) n->data;
558
559			if (cu->chan == chan)
560			return cu;
561			}
562			}
563			else
564			{
565			LIST_FOREACH (n, chan->members.head)
566			{
567			cu = (chanuser_t *) n->data;
568
569			if (cu->user == user)
570			return cu;
571			}
572			}
573
574			return NULL;
575			}
576
577			/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
578			* vim:ts=8
579			* vim:sw=8
580			* vim:noexpandtab
581			*/