lib/eggdrop/partychan.c File Reference

#include <eggdrop/eggdrop.h>

Go to the source code of this file.

Defines
#define	CID_WRAPAROUND   100000
Functions
int	partychan_init (void)
int	partychan_shutdown (void)
int	partychan_get_cid ()
partychan_t *	partychan_new (int cid, const char *name)
static int	partychan_cleanup (partychan_t *chan)
void	partychan_delete (partychan_t *chan)
partychan_t *	partychan_lookup_cid (int cid)
partychan_t *	partychan_lookup_name (const char *name)
partychan_t *	partychan_get_default (partymember_t *p)
int	partychan_ison_name (const char *chan, partymember_t *p)
int	partychan_ison (partychan_t *chan, partymember_t *p)
int	partychan_join_name (const char *chan, partymember_t *p, int linking)
int	partychan_join_cid (int cid, partymember_t *p, int linking)
int	partychan_join (partychan_t *chan, partymember_t *p, int linking)
int	partychan_part_name (const char *chan, partymember_t *p, const char *text)
int	partychan_part_cid (int cid, partymember_t *p, const char *text)
int	partychan_part (partychan_t *chan, partymember_t *p, const char *text)
static int	chan_msg (partychan_t *chan, botnet_entity_t *src, const char *text, int len, int local)
int	partychan_msg_name (const char *name, botnet_entity_t *src, const char *text, int len)
int	partychan_msg_cid (int cid, botnet_entity_t *src, const char *text, int len)
int	partychan_msg (partychan_t *chan, botnet_entity_t *src, const char *text, int len)
int	localchan_msg (partychan_t *chan, botnet_entity_t *src, const char *text, int len)
partymember_common_t *	partychan_get_common (partymember_t *p)
int	partychan_free_common (partymember_common_t *common)
Variables
static const char	rcsid [] = "$Id: partychan.c,v 1.25 2007-04-18 01:45:52 sven Exp $"
static hash_table_t *	cid_ht = NULL
static partychan_t *	partychan_head = NULL
static int	g_cid = 0
static partymember_common_t *	common_list_head = NULL
static bind_table_t *	BT_partyjoin = NULL
static bind_table_t *	BT_partypart = NULL
static bind_table_t *	BT_partypub = NULL

---

Define Documentation

#define CID_WRAPAROUND   100000

Definition at line 27 of file partychan.c.

Referenced by partychan_get_cid().

---

Function Documentation

static int chan_msg	(	partychan_t *	chan,
		botnet_entity_t *	src,
		const char *	text,
		int	len,
		int	local
	)			[static]

Definition at line 350 of file partychan.c.

References bind_check(), botnet_chanmsg(), BT_partypub, partychan::cid, partymember::client_data, partymember::flags, partychan_member::flags, partychan::flags, partymember::handler, partychan::members, partychan::name, partychan::nmembers, NULL, partyline_event::on_chanmsg, partychan_member::p, and PARTY_DELETED.

Referenced by localchan_msg(), partychan_msg(), partychan_msg_cid(), and partychan_msg_name().

{
  partychan_member_t *mem;
  int i;

  if (!chan || chan->flags & PARTY_DELETED) return(-1);

  if (len < 0) len = strlen(text);

  /* Trigger the partyline channel pub bind. */
  bind_check(BT_partypub, NULL, NULL, chan->name, chan->cid, src, text, len);

  for (i = 0; i < chan->nmembers; i++) {
    mem = chan->members+i;
    if (mem->flags & PARTY_DELETED || mem->p->flags & PARTY_DELETED) continue;
    if (mem->p->handler && mem->p->handler->on_chanmsg)
      (mem->p->handler->on_chanmsg)(mem->p->client_data, chan, src, text, len);
  }

  if (!local) botnet_chanmsg(chan, src, text, len);

  return(0);
}

int localchan_msg	(	partychan_t *	chan,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 395 of file partychan.c.

References chan_msg().

Referenced by on_putlog().

{
  return chan_msg(chan, src, text, len, 1);
}

static int partychan_cleanup

(

partychan_t *

chan

)

[static]

Definition at line 116 of file partychan.c.

References partymember::channels, partychan_member::flags, partychan::flags, partychan::members, partychan::name, partymember::nchannels, partychan::next, partychan::nmembers, NULL, partychan_member::p, PARTY_DELETED, and partychan::prev.

Referenced by partychan_delete(), and partychan_part().

{
  int i;

  if (chan->flags & PARTY_DELETED) {
    /* Following is bulky code to resolve recursive referencing.
       Don't bother reading it (unless hunting for bugs).
       All it does is searches through a memeber list of a channel
       and then updates each member so to NOT contain said channel in it's
       channel list. Eh, sounds funky even in English. */
       
    for (i = 0; i < chan->nmembers; i++) {
      int j;
      for (j = 0; j < chan->members[i].p->nchannels; j++) {
        if (chan == chan->members[i].p->channels[j]) {
          if (j + 1 < chan->members[i].p->nchannels)
            memmove(chan->members[i].p->channels[j], chan->members[i].p->channels[j+1],
                (chan->members[i].p->nchannels-j-1) * sizeof(*chan));
          chan->members[i].p->nchannels--;
          break;
        }
      }
    }

    if (chan->prev) {
      chan->prev->next = chan->next;
      if (chan->next)
        chan->next->prev = chan->prev;
    }
    else if (chan->next)
      chan->next->prev = NULL;

    free(chan->name);
    free(chan->members);
    free(chan);
    return(0);
  }

  for (i = 0; i < chan->nmembers; i++) {
    if (chan->members[i].flags & PARTY_DELETED) {
      memmove(chan->members+i, chan->members+i+1, sizeof(*chan->members) * (chan->nmembers-i-1));
      chan->nmembers--;
      i--;
    }
  }

  return(0);
}

void partychan_delete

(

partychan_t *

chan

)

Definition at line 165 of file partychan.c.

References partychan::cid, partychan::flags, garbage_add(), GARBAGE_ONCE, hash_table_remove(), NULL, PARTY_DELETED, and partychan_cleanup().

Referenced by partychan_shutdown().

{
  chan->flags |= PARTY_DELETED;
  hash_table_remove(cid_ht, (void *)chan->cid, NULL);
  garbage_add((garbage_proc_t)partychan_cleanup, chan, GARBAGE_ONCE);
}

int partychan_free_common

(

partymember_common_t *

common

)

Definition at line 438 of file partychan.c.

References partymember_common::len, and partymember_common::next.

Referenced by partymember_delete(), and partymember_set_nick().

{
  common->len = 0;
  common->next = common_list_head;
  common_list_head = common;
  return(0);
}

int partychan_get_cid

(

)

Definition at line 89 of file partychan.c.

References CID_WRAPAROUND, g_cid, and partychan_lookup_cid().

Referenced by partychan_new().

{
  int cid;

  while (partychan_lookup_cid(g_cid)) {
    g_cid++;
    if (g_cid >= CID_WRAPAROUND) g_cid = 0;
  }
  cid = g_cid++;
  if (g_cid >= CID_WRAPAROUND) g_cid = 0;
  return(cid);
}

partymember_common_t* partychan_get_common

(

partymember_t *

p

)

Definition at line 401 of file partychan.c.

References partymember::bot, partymember::channels, partymember::flags, partychan_member::flags, partychan::flags, partymember_common::len, partymember_common::max, partymember_common::members, partychan::members, partymember::nchannels, partymember_common::next, partychan::nmembers, partychan_member::p, PARTY_DELETED, and PARTY_SELECTED.

Referenced by partymember_delete(), and partymember_set_nick().

{
  partymember_common_t *common;
  partychan_t *chan;
  partymember_t *mem;
  int i, j;

  if (common_list_head) {
    common = common_list_head;
    common_list_head = common_list_head->next;
  }
  else {
    common = calloc(1, sizeof(*common));
  }

  common->len = 0;
  for (i = 0; i < p->nchannels; i++) {
    chan = p->channels[i];
    if (chan->flags & PARTY_DELETED) continue;
    for (j = 0; j < chan->nmembers; j++) {
      if (chan->members[j].flags & PARTY_DELETED) continue;
      mem = chan->members[j].p;
      if (mem->flags & (PARTY_DELETED | PARTY_SELECTED)) continue;
      if (mem->bot) continue;
      mem->flags |= PARTY_SELECTED;
      if (common->len >= common->max) {
        common->max = common->len + 10;
        common->members = realloc(common->members, sizeof(*common->members) * common->max);
      }
      common->members[common->len] = mem;
      common->len++;
    }
  }
  for (i = 0; i < common->len; i++) common->members[i]->flags &= ~PARTY_SELECTED;
  return(common);
}

partychan_t* partychan_get_default

(

partymember_t *

p

)

Definition at line 192 of file partychan.c.

References partymember::channels, partymember::nchannels, and NULL.

Referenced by got_join(), party_chanmembermode(), party_part(), and partyline_on_input().

{
  if (p->nchannels > 0) return(p->channels[p->nchannels-1]);
  return(NULL);
}

int partychan_init

(

void

)

Definition at line 39 of file partychan.c.

References BIND_STACKABLE, bind_table_add(), BT_partypart, BT_partypub, BTN_PARTYLINE_JOIN, BTN_PARTYLINE_PART, BTN_PARTYLINE_PUBLIC, hash_table_create(), HASH_TABLE_INTS, MATCH_NONE, and NULL.

Referenced by partyline_init().

{
  cid_ht = hash_table_create(NULL, NULL, 13, HASH_TABLE_INTS);

  /* The first 3 args for each bind are:
   * channel name, channel id, partier */
  BT_partyjoin = bind_table_add(BTN_PARTYLINE_JOIN, 3, "siP", MATCH_NONE, BIND_STACKABLE);  /* DDD  */
  BT_partypart = bind_table_add(BTN_PARTYLINE_PART, 5, "siPsi", MATCH_NONE, BIND_STACKABLE);  /* DDD  */
  BT_partypub = bind_table_add(BTN_PARTYLINE_PUBLIC, 5, "siEsi", MATCH_NONE, BIND_STACKABLE); /* DDD  */
  return(0);
}

int partychan_ison	(	partychan_t *	chan,
		partymember_t *	p
	)

Definition at line 208 of file partychan.c.

References egg_assert_val, partychan_member::flags, partychan::members, partychan::nmembers, NULL, partychan_member::p, and PARTY_DELETED.

Referenced by partychan_ison_name().

{
  int i;

  egg_assert_val (chan != NULL, 0);
  egg_assert_val (p != NULL, 0);
  
  for (i = 0; i < chan->nmembers; i++) {
    if (chan->members[i].flags & PARTY_DELETED) continue;
    if (chan->members[i].p == p) return(1);
  }
    
  return(0);
}

int partychan_ison_name	(	const char *	chan,
		partymember_t *	p
	)

Definition at line 198 of file partychan.c.

References partychan_ison(), and partychan_lookup_name().

{
  partychan_t *chanptr;

  if (!chan) return(0);
  chanptr = partychan_lookup_name(chan);
  if (!chanptr) return(0);
  return partychan_ison(chanptr, p);
}

int partychan_join	(	partychan_t *	chan,
		partymember_t *	p,
		int	linking
	)

Definition at line 241 of file partychan.c.

References bind_check(), botnet_member_join(), partymember::channels, partychan::cid, partymember::client_data, partymember::flags, partychan_member::flags, partymember::handler, partychan::members, partychan::name, partymember::nchannels, partychan::nmembers, NULL, partyline_event::on_join, partychan_member::p, and PARTY_DELETED.

Referenced by partychan_join_cid(), and partychan_join_name().

{
  partychan_member_t *mem;
  int i;

  if (!chan || !p) return(-1);

  /* Check to see if he's already on. We put this here just to save some
   * redundancy in partyline modules. */
  for (i = 0; i < chan->nmembers; i++) {
    if (chan->members[i].flags & PARTY_DELETED) continue;
    if (chan->members[i].p == p) return(-1);
  }

  /* Add the member. */
  chan->members = realloc(chan->members, sizeof(*chan->members) * (chan->nmembers+1));
  chan->members[chan->nmembers].p = p;
  chan->members[chan->nmembers].flags = 0;
  chan->nmembers++;

  /* Now add the channel to the member's list. */
  p->channels = realloc(p->channels, sizeof(chan) * (p->nchannels+1));
  p->channels[p->nchannels] = chan;
  p->nchannels++;

  /* Trigger the partyline channel join bind. */
  bind_check(BT_partyjoin, NULL, NULL, chan->name, chan->cid, p);

  /* Send out the join event to the members. */
  for (i = 0; i < chan->nmembers; i++) {
    mem = chan->members+i;
    if (mem->flags & PARTY_DELETED || mem->p->flags & PARTY_DELETED) continue;
    if (mem->p->handler && mem->p->handler->on_join)
      (mem->p->handler->on_join)(mem->p->client_data, chan, p, linking);
  }

  botnet_member_join(chan, p, linking);

  return(0);
}

int partychan_join_cid	(	int	cid,
		partymember_t *	p,
		int	linking
	)

Definition at line 233 of file partychan.c.

References partychan_join(), and partychan_lookup_cid().

{
  partychan_t *chanptr;

  chanptr = partychan_lookup_cid(cid);
  return partychan_join(chanptr, p, linking);
}

int partychan_join_name	(	const char *	chan,
		partymember_t *	p,
		int	linking
	)

Definition at line 223 of file partychan.c.

References partychan_join(), partychan_lookup_name(), and partychan_new().

Referenced by dcc_on_read(), got_join(), irc_on_read(), party_join(), telnet_on_read(), and terminal_init().

{
  partychan_t *chanptr;

  if (!chan) return(-1);
  chanptr = partychan_lookup_name(chan);
  if (!chanptr) chanptr = partychan_new(-1, chan);
  return partychan_join(chanptr, p, linking);
}

partychan_t* partychan_lookup_cid

(

int

cid

)

Definition at line 172 of file partychan.c.

References partychan::flags, hash_table_find(), NULL, and PARTY_DELETED.

Referenced by partychan_get_cid(), partychan_join_cid(), partychan_msg_cid(), and partychan_part_cid().

{
  partychan_t *chan = NULL;

  hash_table_find(cid_ht, (void *)cid, &chan);
  if (chan && chan->flags & PARTY_DELETED) chan = NULL;
  return(chan);
}

partychan_t* partychan_lookup_name

(

const char *

name

)

Definition at line 181 of file partychan.c.

References partychan::flags, partychan::name, partychan::next, NULL, and PARTY_DELETED.

Referenced by assoc_get_name(), got_privmsg(), got_who(), on_putlog(), party_part(), partychan_ison_name(), partychan_join_name(), partychan_msg_name(), and partychan_part_name().

{
  partychan_t *chan = NULL;

  for (chan = partychan_head; chan; chan = chan->next) {
    if (chan->flags & PARTY_DELETED) continue;
    if (!strcasecmp(name, chan->name)) break;
  }
  return(chan);
}

int partychan_msg	(	partychan_t *	chan,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 390 of file partychan.c.

References chan_msg().

Referenced by partyline_on_input().

{
  return chan_msg(chan, src, text, len, 0);
}

int partychan_msg_cid	(	int	cid,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 382 of file partychan.c.

References chan_msg(), and partychan_lookup_cid().

{
  partychan_t *chan;

  chan = partychan_lookup_cid(cid);
  return chan_msg(chan, src, text, len, 0);
}

int partychan_msg_name	(	const char *	name,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 374 of file partychan.c.

References chan_msg(), and partychan_lookup_name().

Referenced by got_actchan(), got_chanmsg(), and got_chat().

{
  partychan_t *chan;

  chan = partychan_lookup_name(name);
  return chan_msg(chan, src, text, len, 0);
}

partychan_t* partychan_new	(	int	cid,
		const char *	name
	)

Definition at line 102 of file partychan.c.

References partychan::cid, partychan::name, partychan::next, partychan_get_cid(), and partychan::prev.

Referenced by partychan_join_name().

{
  partychan_t *chan;

  chan = calloc(1, sizeof(*chan));
  if (cid == -1) cid = partychan_get_cid();
  chan->cid = cid;
  chan->name = strdup(name);
  chan->next = partychan_head;
  if (partychan_head) partychan_head->prev = chan;
  partychan_head = chan;
  return(chan);
}

int partychan_part	(	partychan_t *	chan,
		partymember_t *	p,
		const char *	text
	)

Definition at line 299 of file partychan.c.

References bind_check(), botnet_member_part(), BT_partypart, partymember::channels, partychan::cid, partymember::client_data, partychan_member::flags, partymember::flags, garbage_add(), GARBAGE_ONCE, partymember::handler, partychan::members, partychan::name, partymember::nchannels, partychan::nmembers, NULL, partyline_event::on_part, partychan_member::p, PARTY_DELETED, and partychan_cleanup().

Referenced by got_join(), party_part(), partychan_part_cid(), partychan_part_name(), and partymember_delete().

{
  int i, len;
  partychan_member_t *mem;

  if (!chan || !p) return(-1);

  /* Remove the channel entry from the member. */
  if (!(p->flags & PARTY_DELETED)) for (i = 0; i < p->nchannels; i++) {
    if (p->channels[i] == chan) {
      memmove(p->channels+i, p->channels+i+1, sizeof(chan) * (p->nchannels-i-1));
      p->nchannels--;
      break;
    }
  }

  /* Mark the member to be deleted. */
  for (i = 0; i < chan->nmembers; i++) {
    if (chan->members[i].flags & PARTY_DELETED) continue;
    if (chan->members[i].p == p) {
      chan->members[i].flags |= PARTY_DELETED;
      garbage_add((garbage_proc_t)partychan_cleanup, chan, GARBAGE_ONCE);
      break;
    }
  }

  /* If the member is already deleted, then the quit event has been
   * fired already. */
  if (p->flags & PARTY_DELETED) return(0);

  if (!text) text = "";
  len = strlen(text);

  /* Trigger the partyline channel part bind. */
  bind_check(BT_partypart, NULL, NULL, chan->name, chan->cid, p, text, len);

  if (p->handler && p->handler->on_part) p->handler->on_part(p->client_data, chan, p, text, len);

  /* Send out the part event to the members. */
  for (i = 0; i < chan->nmembers; i++) {
    mem = chan->members+i;
    if (mem->flags & PARTY_DELETED || mem->p->flags & PARTY_DELETED) continue;
    if (mem->p->handler && mem->p->handler->on_part)
      (mem->p->handler->on_part)(mem->p->client_data, chan, p, text, len);
  }

  botnet_member_part(chan, p, text, len);

  return(0);
}

int partychan_part_cid	(	int	cid,
		partymember_t *	p,
		const char *	text
	)

Definition at line 291 of file partychan.c.

References partychan_lookup_cid(), and partychan_part().

{
  partychan_t *chanptr;

  chanptr = partychan_lookup_cid(cid);
  return partychan_part(chanptr, p, text);
}

int partychan_part_name	(	const char *	chan,
		partymember_t *	p,
		const char *	text
	)

Definition at line 282 of file partychan.c.

References partychan_lookup_name(), and partychan_part().

Referenced by got_part().

{
  partychan_t *chanptr;

  if (!chan) return(-1);
  chanptr = partychan_lookup_name(chan);
  return partychan_part(chanptr, p, text);
}

int partychan_shutdown

(

void

)

Definition at line 51 of file partychan.c.

References bind_table_del(), BT_partypart, BT_partypub, garbage_run(), hash_table_delete(), partymember_common::members, partymember_common::next, partychan::next, NULL, and partychan_delete().

Referenced by partyline_shutdown().

{
  partychan_t *chan, *next;
  partymember_common_t *common, *next_common;

  if (partychan_head != NULL) {
    for (chan = partychan_head; chan; ) {
      next = chan->next;
      partychan_delete(chan);
      chan = next;
    }
    partychan_head = NULL;
  }

  if (common_list_head) {
    for (common = common_list_head; common; ) {
      next_common = common->next;

      free(common->members);
      free(common);

      common = next_common;
    } 
    common_list_head = NULL;
  }

  bind_table_del(BT_partypub);
  bind_table_del(BT_partypart);
  bind_table_del(BT_partyjoin);
  
  /* flush any pending partychan deletes */
  garbage_run();

  hash_table_delete(cid_ht);

  return (0);
}

---

Variable Documentation

bind_table_t* BT_partyjoin = NULL [static]

Definition at line 35 of file partychan.c.

bind_table_t * BT_partypart = NULL [static]

Definition at line 36 of file partychan.c.

Referenced by partychan_init(), partychan_part(), and partychan_shutdown().

bind_table_t * BT_partypub = NULL [static]

Definition at line 37 of file partychan.c.

Referenced by chan_msg(), partychan_init(), and partychan_shutdown().

hash_table_t* cid_ht = NULL [static]

Definition at line 29 of file partychan.c.

partymember_common_t* common_list_head = NULL [static]

Definition at line 32 of file partychan.c.

int g_cid = 0 [static]

Definition at line 31 of file partychan.c.

Referenced by partychan_get_cid().

partychan_t* partychan_head = NULL [static]

Definition at line 30 of file partychan.c.

const char rcsid[] = "$Id: partychan.c,v 1.25 2007-04-18 01:45:52 sven Exp $" [static]

Definition at line 21 of file partychan.c.