lib/eggdrop/binds.c File Reference

#include <eggdrop/eggdrop.h>

Go to the source code of this file.

Functions
static int	bind_vcheck_hits (bind_table_t *table, flags_t *user_flags, const char *match, int *hits, va_list args)
static void	bind_table_really_del (bind_table_t *table)
static void	bind_entry_really_del (bind_table_t *table, bind_entry_t *entry)
bind_table_t *	bind_table_list (void)
static int	internal_bind_cleanup ()
static void	schedule_bind_cleanup ()
void	kill_binds (void)
int	kill_binds_by_owner (egg_module_t *module, void *script)
bind_table_t *	bind_table_add (const char *name, int nargs, const char *syntax, int match_type, int flags)
void	bind_table_del (bind_table_t *table)
bind_table_t *	bind_table_lookup (const char *name)
bind_table_t *	bind_table_lookup_or_fake (const char *name)
bind_entry_t *	bind_entry_lookup (bind_table_t *table, const char *mask, const char *function_name, Function callback)
int	bind_entry_del (bind_table_t *table, const char *mask, const char *function_name, Function callback)
int	bind_entry_modify (bind_table_t *table, const char *mask, const char *function_name, const char *newflags, const char *newmask)
int	bind_entry_overwrite (bind_table_t *table, const char *mask, const char *function_name, Function callback, void *client_data, event_owner_t *owner)
int	bind_entry_add (bind_table_t *table, const char *flags, const char *mask, const char *function_name, int bind_flags, Function callback, void *client_data, event_owner_t *owner)
static int	bind_entry_exec (bind_table_t *table, bind_entry_t *entry, void **al)
int	bind_check (bind_table_t *table, flags_t *user_flags, const char *match,...)
int	bind_check_hits (bind_table_t *table, flags_t *user_flags, const char *match, int *hits,...)
void	bind_add_list (const char *table_name, bind_list_t *cmds)
void	bind_add_simple (const char *table_name, const char *flags, const char *mask, Function callback)
void	bind_rem_list (const char *table_name, bind_list_t *cmds)
void	bind_rem_simple (const char *table_name, const char *flags, const char *mask, Function callback)
Variables
static const char	rcsid [] = "$Id: binds.c,v 1.30 2007-01-13 12:23:39 sven Exp $"
static bind_table_t *	bind_table_list_head = NULL

---

Function Documentation

void bind_add_list	(	const char *	table_name,
		bind_list_t *	cmds
	)

Definition at line 459 of file binds.c.

References bind_entry_add(), bind_table_lookup_or_fake(), bind_list_t::callback, bind_list_t::mask, bind_table_b::name, NULL, and bind_list_t::user_flags.

Referenced by channel_events_init(), core_party_init(), irc_init(), javascript_LTX_start(), oldbotnet_init(), partyline_init(), partymember_init(), perlscript_LTX_start(), pythonscript_LTX_start(), server_binds_init(), and tclscript_LTX_start().

{
  char name[50];
  bind_table_t *table;

  table = bind_table_lookup_or_fake(table_name);

  for (; cmds->callback; cmds++) {
    snprintf(name, 50, "*%s:%s", table->name, cmds->mask ? cmds->mask : "");
    name[49] = 0;
    bind_entry_add(table, cmds->user_flags, cmds->mask, name, 0, cmds->callback, NULL, NULL);
  }
}

void bind_add_simple	(	const char *	table_name,
		const char *	flags,
		const char *	mask,
		Function	callback
	)

Definition at line 473 of file binds.c.

References bind_entry_add(), bind_table_lookup_or_fake(), bind_table_b::name, and NULL.

Referenced by bot_init(), chanserv_init(), dcc_init(), events_init(), logfile_init(), oldbotnet_init(), proxy_init(), and user_init().

{
  char name[50];
  bind_table_t *table;

  table = bind_table_lookup_or_fake(table_name);

  snprintf(name, sizeof(name), "*%s:%s", table->name, mask ? mask : "");
  name[sizeof(name)-1] = 0;
  
  bind_entry_add(table, flags, mask, name, 0, callback, NULL, NULL);
}

int bind_check	(	bind_table_t *	table,
		flags_t *	user_flags,
		const char *	match,
			...
	)

Definition at line 367 of file binds.c.

References bind_vcheck_hits(), and NULL.

Referenced by botnet_botbroadcast(), botnet_botmsg(), botnet_extension(), botnet_link(), botnet_new(), botnet_recursive_delete(), chan_msg(), channel_on_leave(), channel_set(), chanserv_update_stats(), check_bind_init(), check_bind_secondly(), check_bind_shutdown(), check_bind_status(), check_bind_time(), check_ctcp_ctcr(), check_flag_change(), config_save(), config_set_int(), config_set_str(), do_output(), eggdrop_event(), got_chat(), got_send(), gotjoin(), gotkick(), gotmode(), gotmsg(), gotnick(), gotnotice(), gotpart(), gotquit(), gotwall(), irc_on_read(), module_load(), module_unload(), oldbotnet_on_read(), parse_chan_mode(), partychan_join(), partychan_part(), partymember_delete(), partymember_new(), partymember_set_nick(), putlog(), server_parse_input(), user_delete(), and user_set_setting().

{
  va_list args;
  int ret;

  va_start(args, match);
  ret = bind_vcheck_hits(table, user_flags, match, NULL, args); 
  va_end(args);

  return ret;
}

int bind_check_hits	(	bind_table_t *	table,
		flags_t *	user_flags,
		const char *	match,
		int *	hits,
			...
	)

Definition at line 379 of file binds.c.

References bind_vcheck_hits().

Referenced by partyline_on_command().

{
  va_list args;
  int ret;

  va_start(args, hits);
  ret = bind_vcheck_hits(table, user_flags, match, hits, args);
  va_end(args);

  return ret;
}

int bind_entry_add	(	bind_table_t *	table,
		const char *	flags,
		const char *	mask,
		const char *	function_name,
		int	bind_flags,
		Function	callback,
		void *	client_data,
		event_owner_t *	owner
	)

Definition at line 278 of file binds.c.

References bind_entry_lookup(), BIND_STACKABLE, bind_entry_b::callback, bind_entry_b::client_data, bind_table_b::entries, flag_from_str(), bind_entry_b::flags, bind_table_b::flags, bind_entry_b::function_name, bind_entry_b::mask, bind_entry_b::next, NULL, event_owner_b::on_delete, bind_entry_b::owner, bind_entry_b::prev, and bind_entry_b::user_flags.

Referenced by bind_add_list(), bind_add_simple(), channel_events_init(), and script_bind().

{
  bind_entry_t *entry, *old_entry;

  old_entry = bind_entry_lookup(table, mask, function_name, NULL);

  if (old_entry) {
    if (table->flags & BIND_STACKABLE) {
      entry = calloc(1, sizeof(*entry));
      entry->prev = old_entry;
      entry->next = old_entry->next;
      old_entry->next = entry;
      if (entry->next) entry->next->prev = entry;
    }
    else {
      entry = old_entry;
      if (entry->owner && entry->owner->on_delete) entry->owner->on_delete(entry->owner, entry->client_data);
      if (entry->function_name) free(entry->function_name);
      if (entry->mask) free(entry->mask);
    }
  }
  else {
    for (old_entry = table->entries; old_entry && old_entry->next; old_entry = old_entry->next) {
      ; /* empty loop */
    }
    entry = calloc(1, sizeof(*entry));
    if (old_entry) old_entry->next = entry;
    else table->entries = entry;
    entry->prev = old_entry;
  }

  if (flags) flag_from_str(&entry->user_flags, flags);
  if (mask) entry->mask = strdup(mask);
  if (function_name) entry->function_name = strdup(function_name);
  entry->callback = callback;
  entry->client_data = client_data;
  entry->flags = bind_flags;
  entry->owner = owner;

  return(0);
}

int bind_entry_del	(	bind_table_t *	table,
		const char *	mask,
		const char *	function_name,
		Function	callback
	)

Definition at line 206 of file binds.c.

References BIND_DELETED, bind_entry_lookup(), bind_table_b::entries, bind_entry_b::flags, bind_entry_b::function_name, LOG_DEBUG, bind_entry_b::mask, bind_table_b::name, bind_entry_b::next, NULL, putlog(), and schedule_bind_cleanup().

Referenced by bind_rem_list(), bind_rem_simple(), and script_unbind().

{
  bind_entry_t *entry;

  entry = bind_entry_lookup(table, mask, function_name, callback);
  
  /* better to issue a warning message than silently ignoring 
   * that this entry is not found...at least for now */
  if (entry == NULL) {
    if (table) {
      putlog(LOG_DEBUG, "*", "A bind entry '%s/%s' is marked for destroying but isn't found in table '%s'.",
        mask, function_name, table->name);
      putlog(LOG_DEBUG, "*", "Current entries are:");
      for (entry = table->entries; entry; entry = entry->next) {
        putlog(LOG_DEBUG, "*", "  %s/%s", entry->mask, entry->function_name);
      }
    } else {
      putlog(LOG_DEBUG, "*", "A bind entry '%s/%s' is marked for destroying but isn't found in any table.",
        mask, function_name);
    }
    return -1;
  }
  /*if (!entry) return(-1);*/

  /* Delete it. */
  entry->flags |= BIND_DELETED;
  schedule_bind_cleanup();
  return(0);
}

static int bind_entry_exec	(	bind_table_t *	table,
		bind_entry_t *	entry,
		void **	al
	)			[static]

Definition at line 321 of file binds.c.

References BIND_DELETED, BIND_WANTS_CD, bind_entry_b::callback, bind_entry_b::client_data, bind_table_b::entries, bind_entry_b::flags, MATCH_MASK, MATCH_NONE, MATCH_PARTIAL, bind_table_b::match_type, bind_entry_b::next, bind_entry_b::nhits, and bind_entry_b::prev.

Referenced by bind_vcheck_hits().

{
  bind_entry_t *prev;
  int retval;

  /* Give this entry a hit. */
  entry->nhits++;

  /* Does the callback want client data? */
  if (entry->flags & BIND_WANTS_CD) {
    *al = entry->client_data;
  }
  else al++;

  retval = entry->callback(al[0], al[1], al[2], al[3], al[4], al[5], al[6], al[7], al[8], al[9]);

  if (table->match_type & (MATCH_MASK | MATCH_PARTIAL | MATCH_NONE)) return(retval);

  /* Search for the last entry that isn't deleted. */
  for (prev = entry->prev; prev; prev = prev->prev) {
    if (!(prev->flags & BIND_DELETED) && (prev->nhits >= entry->nhits)) break;
  }

  /* See if this entry is more popular than the preceding one. */
  if (entry->prev != prev) {
    /* Remove entry. */
    if (entry->prev) entry->prev->next = entry->next;
    else table->entries = entry->next;
    if (entry->next) entry->next->prev = entry->prev;

    /* Re-add in correct position. */
    if (prev) {
      entry->next = prev->next;
      if (prev->next) prev->next->prev = entry;
      prev->next = entry;
    }
    else {
      entry->next = table->entries;
      table->entries = entry;
    }
    entry->prev = prev;
    if (entry->next) entry->next->prev = entry;
  }
  return(retval);
}

bind_entry_t* bind_entry_lookup	(	bind_table_t *	table,
		const char *	mask,
		const char *	function_name,
		Function	callback
	)

Definition at line 180 of file binds.c.

References BIND_DELETED, bind_entry_b::callback, bind_table_b::entries, bind_entry_b::flags, bind_entry_b::function_name, bind_entry_b::mask, bind_entry_b::next, bind_table_b::next, and NULL.

Referenced by bind_entry_add(), bind_entry_del(), bind_entry_modify(), and bind_entry_overwrite().

{
  bind_entry_t *entry = NULL;
  int hit, searchall = 0;

  if (!table) {
    searchall = 1;
    table = bind_table_list_head;
  }
  
  for (; table; table = table->next) {
    for (entry = table->entries; entry; entry = entry->next) {
      if (entry->flags & BIND_DELETED) continue;
      else {
        hit = 0;
        if (!entry->mask || !strcmp(entry->mask, mask)) hit++;
        if (!entry->function_name || !strcmp(entry->function_name, function_name)) hit++;
        if (!callback || entry->callback == callback) hit++;
        if (hit == 3) break;
      }
    }
    if (entry || !searchall) break;
  }
  return(entry);
}

int bind_entry_modify	(	bind_table_t *	table,
		const char *	mask,
		const char *	function_name,
		const char *	newflags,
		const char *	newmask
	)

Definition at line 249 of file binds.c.

References bind_entry_lookup(), flag_from_str(), bind_entry_b::mask, NULL, str_redup(), and bind_entry_b::user_flags.

Referenced by script_rebind().

{
  bind_entry_t *entry;

  entry = bind_entry_lookup(table, mask, function_name, NULL);
  if (!entry) return(-1);

  /* Modify it. */
  if (newflags) flag_from_str(&entry->user_flags, newflags);
  if (newmask) str_redup(&entry->mask, newmask);

  return(0);
}

int bind_entry_overwrite	(	bind_table_t *	table,
		const char *	mask,
		const char *	function_name,
		Function	callback,
		void *	client_data,
		event_owner_t *	owner
	)

Definition at line 264 of file binds.c.

References bind_entry_lookup(), bind_entry_b::client_data, NULL, event_owner_b::on_delete, and bind_entry_b::owner.

{
  bind_entry_t *entry;

  entry = bind_entry_lookup(table, mask, function_name, NULL);
  if (!entry) return(-1);

  if ((entry->client_data != client_data || entry->owner != owner) && entry->owner && entry->owner->on_delete) entry->owner->on_delete(entry->owner, entry->client_data);
  callback = callback;
  entry->client_data = client_data;
  entry->owner = owner;
  return(0);
}

static void bind_entry_really_del	(	bind_table_t *	table,
		bind_entry_t *	entry
	)			[static]

Definition at line 236 of file binds.c.

References bind_entry_b::client_data, bind_table_b::entries, bind_entry_b::function_name, bind_entry_b::mask, bind_entry_b::next, event_owner_b::on_delete, bind_entry_b::owner, and bind_entry_b::prev.

Referenced by internal_bind_cleanup().

{
  if (entry->next) entry->next->prev = entry->prev;
  if (entry->prev) entry->prev->next = entry->next;
  else table->entries = entry->next;

  if (entry->owner && entry->owner->on_delete) entry->owner->on_delete(entry->owner, entry->client_data);
  if (entry->function_name) free(entry->function_name);
  if (entry->mask) free(entry->mask);
  free(entry);
}

void bind_rem_list	(	const char *	table_name,
		bind_list_t *	cmds
	)

Definition at line 486 of file binds.c.

References bind_entry_del(), bind_table_lookup(), bind_list_t::callback, bind_list_t::mask, and bind_table_b::name.

Referenced by channel_events_destroy(), javascript_close(), oldbotnet_close(), partyline_shutdown(), partymember_shutdown(), perlscript_close(), pythonscript_close(), server_close(), and tclscript_close().

{
  char name[50];
  bind_table_t *table;

  table = bind_table_lookup(table_name);
  if (!table) return;

  for (; cmds->callback; cmds++) {
    snprintf(name, sizeof(name), "*%s:%s", table->name, cmds->mask ? cmds->mask : "");
    name[sizeof(name)-1] = 0;
    bind_entry_del(table, cmds->mask, name, cmds->callback);
  }
}

void bind_rem_simple	(	const char *	table_name,
		const char *	flags,
		const char *	mask,
		Function	callback
	)

Definition at line 501 of file binds.c.

References bind_entry_del(), bind_table_lookup(), and bind_table_b::name.

Referenced by bot_close(), events_shutdown(), logfile_shutdown(), oldbotnet_close(), and server_close().

{
  char name[50];
  bind_table_t *table;

  table = bind_table_lookup(table_name);
  if (!table) return;

  snprintf(name, sizeof(name), "*%s:%s", table->name, mask ? mask : "");
  name[sizeof(name)-1] = 0;
  bind_entry_del(table, mask, name, callback);
}

bind_table_t* bind_table_add	(	const char *	name,
		int	nargs,
		const char *	syntax,
		int	match_type,
		int	flags
	)

Definition at line 90 of file binds.c.

References BIND_FAKE, bind_table_b::flags, bind_table_b::match_type, bind_table_b::name, bind_table_b::nargs, bind_table_b::next, and bind_table_b::syntax.

Referenced by bind_table_lookup_or_fake(), botnet_init(), chanserv_init(), config_init(), core_binds_init(), eggdrop_init(), irc_init(), logging_init(), module_init(), oldbotnet_init(), partychan_init(), partyline_init(), partymember_init(), server_binds_init(), start(), and user_init().

{
  bind_table_t *table;

  for (table = bind_table_list_head; table; table = table->next) {
    if (!strcmp(table->name, name)) break;
  }

  /* If it doesn't exist, create it. */
  if (!table) {
    table = calloc(1, sizeof(*table));
    table->name = strdup(name);
    table->next = bind_table_list_head;
    bind_table_list_head = table;
  }
  else if (!(table->flags & BIND_FAKE)) return(table);

  table->nargs = nargs;
  if (syntax) table->syntax = strdup(syntax);
  table->match_type = match_type;
  table->flags = flags;
  return(table);
}

void bind_table_del

(

bind_table_t *

table

)

Definition at line 114 of file binds.c.

References BIND_DELETED, egg_assert, bind_table_b::flags, bind_table_b::name, bind_table_b::next, NULL, and schedule_bind_cleanup().

Referenced by botnet_shutdown(), chanserv_shutdown(), config_shutdown(), core_binds_shutdown(), eggdrop_shutdown(), filesys_close(), kill_binds(), logging_shutdown(), module_shutdown(), oldbotnet_close(), partychan_shutdown(), partyline_shutdown(), partymember_shutdown(), server_binds_destroy(), and user_shutdown().

{
  bind_table_t *cur;

  for (cur = bind_table_list_head; cur; cur = cur->next) {
    if (!strcmp(table->name, cur->name)) break;
  }

  egg_assert(cur != NULL);

  /* Now mark it as deleted. */
  table->flags |= BIND_DELETED;
  schedule_bind_cleanup();
}

bind_table_t* bind_table_list

(

void

)

Definition at line 36 of file binds.c.

Referenced by party_binds().

{
  return bind_table_list_head;
}

bind_table_t* bind_table_lookup

(

const char *

name

)

Definition at line 160 of file binds.c.

References BIND_DELETED, bind_table_b::flags, bind_table_b::name, and bind_table_b::next.

Referenced by bind_rem_list(), bind_rem_simple(), bind_table_lookup_or_fake(), script_bind(), script_rebind(), and script_unbind().

{
  bind_table_t *table;

  for (table = bind_table_list_head; table; table = table->next) {
    if (!(table->flags & BIND_DELETED) && !strcmp(table->name, name)) break;
  }
  return(table);
}

bind_table_t* bind_table_lookup_or_fake

(

const char *

name

)

Definition at line 170 of file binds.c.

References BIND_FAKE, bind_table_add(), bind_table_lookup(), and NULL.

Referenced by bind_add_list(), bind_add_simple(), and channel_events_init().

{
  bind_table_t *table;

  table = bind_table_lookup(name);
  if (!table) table = bind_table_add(name, 0, NULL, 0, BIND_FAKE);
  return(table);
}

static void bind_table_really_del

(

bind_table_t *

table

)

[static]

Definition at line 129 of file binds.c.

References bind_entry_b::client_data, bind_table_b::entries, bind_entry_b::function_name, LOG_DEBUG, bind_entry_b::mask, bind_table_b::name, bind_entry_b::next, bind_table_b::next, NULL, event_owner_b::on_delete, bind_entry_b::owner, putlog(), and bind_table_b::syntax.

Referenced by internal_bind_cleanup().

{
  bind_table_t *cur, *prev;
  bind_entry_t *entry, *next;

  for (prev = NULL, cur = bind_table_list_head; cur; prev = cur, cur = cur->next) {
    if (cur == table)
      break;
  }

  if (cur == NULL) {
    putlog(LOG_DEBUG, "*", "bind table '%s' is marked for destroying but isn't found.", table->name);
    return;
  }

  /* unlink it from list */
  if (prev == NULL) bind_table_list_head = table->next;
  else prev->next = table->next;

  for (entry = table->entries; entry; entry = next) {
    next = entry->next;
    if (entry->owner && entry->owner->on_delete) entry->owner->on_delete(entry->owner, entry->client_data);
    if (entry->function_name) free(entry->function_name);
    if (entry->mask) free(entry->mask);
    free(entry);
  }
  if (table->name) free(table->name);
  if (table->syntax) free(table->syntax);
  free(table);
}

static int bind_vcheck_hits	(	bind_table_t *	table,
		flags_t *	user_flags,
		const char *	match,
		int *	hits,
		va_list	args
	)			[static]

Definition at line 391 of file binds.c.

References BIND_BREAKABLE, BIND_DELETED, bind_entry_exec(), BIND_RET_BREAK, flags_t::builtin, bind_table_b::entries, flag_match_partial(), flag_match_subset(), bind_table_b::flags, bind_entry_b::flags, bind_entry_b::mask, MATCH_CASE, MATCH_FLAGS, MATCH_FLAGS_AND, MATCH_MASK, MATCH_NONE, MATCH_PARTIAL, bind_table_b::match_type, bind_table_b::nargs, bind_entry_b::next, NULL, flags_t::udef, bind_entry_b::user_flags, and wild_match_per().

Referenced by bind_check(), and bind_check_hits().

{
  void *args[11];
  bind_entry_t *entry, *next, *winner = NULL;
  int i, cmp, retval;
  int tie = 0, matchlen = 0;

  for (i = 1; i <= table->nargs; i++) {
    args[i] = va_arg(ap, void *);
  }

  if (hits) (*hits) = 0;

  /* Default return value is 0 */
  retval = 0;

  /* Check if we're searching for a partial match. */
  if (table->match_type & MATCH_PARTIAL) matchlen = strlen(match);

  for (entry = table->entries; entry; entry = next) {
    next = entry->next;
    if (entry->flags & BIND_DELETED) continue;

    /* Check flags. */
    if (table->match_type & MATCH_FLAGS) {
      if (!(entry->user_flags.builtin | entry->user_flags.udef)) cmp = 1;
      else if (!user_flags) cmp = 0;
      else if (entry->flags & MATCH_FLAGS_AND) cmp = flag_match_subset(&entry->user_flags, user_flags);
      else cmp = flag_match_partial(user_flags, &entry->user_flags);
      if (!cmp) continue;
    }

    if (table->match_type & MATCH_NONE || !entry->mask) cmp = 0;
    else if (table->match_type & MATCH_MASK) {
      cmp = !wild_match_per(entry->mask, match);
    }
    else if (table->match_type & MATCH_PARTIAL) {
      cmp = 1;
      if (!strncasecmp(match, entry->mask, matchlen)) {
        winner = entry;
        /* Is it an exact match? */
        if (!entry->mask[matchlen]) {
          tie = 1;
          break;
        }
        else tie++;
      }
    }
    else {
      if (table->match_type & MATCH_CASE) cmp = strcmp(entry->mask, match);
      else cmp = strcasecmp(entry->mask, match);
    }
    if (cmp) continue; /* Doesn't match. */

    if (hits) (*hits)++;

    retval = bind_entry_exec(table, entry, args);
    if ((table->flags & BIND_BREAKABLE) && (retval & BIND_RET_BREAK)) break;
  }
  /* If it's a partial match table, see if we have 1 winner. */
  if (winner && tie == 1) {
    if (hits) (*hits)++;
    retval = bind_entry_exec(table, winner, args);
  }

  return(retval);
}

static int internal_bind_cleanup

(

)

[static]

Definition at line 41 of file binds.c.

References BIND_DELETED, bind_entry_really_del(), bind_table_really_del(), bind_table_b::entries, bind_entry_b::flags, bind_table_b::flags, bind_entry_b::next, and bind_table_b::next.

Referenced by kill_binds_by_owner(), and schedule_bind_cleanup().

{
  bind_table_t *table, *next_table;
  bind_entry_t *entry, *next_entry;

  for (table = bind_table_list_head; table; table = next_table) {
    next_table = table->next;
    if (table->flags & BIND_DELETED) {
      bind_table_really_del(table);
      continue;
    }
    for (entry = table->entries; entry; entry = next_entry) {
      next_entry = entry->next;
      if (entry->flags & BIND_DELETED) bind_entry_really_del(table, entry);
    }
  }
  return(0);
}

void kill_binds

(

void

)

Definition at line 65 of file binds.c.

References bind_table_del().

{
  while (bind_table_list_head) bind_table_del(bind_table_list_head);
}

int kill_binds_by_owner	(	egg_module_t *	module,
		void *	script
	)

Definition at line 70 of file binds.c.

References BIND_DELETED, event_owner_b::client_data, bind_table_b::entries, bind_entry_b::flags, bind_table_b::flags, internal_bind_cleanup(), event_owner_b::module, bind_entry_b::next, bind_table_b::next, and bind_entry_b::owner.

Referenced by script_remove_events_by_owner().

{
  int deleted = 0;
  bind_entry_t *entry;
  bind_table_t *table;

  for (table = bind_table_list_head; table; table = table->next) {
    if (table->flags & BIND_DELETED) continue;
    for (entry = table->entries; entry; entry = entry->next) {
      if (entry->flags & BIND_DELETED) continue;
      if (entry->owner && entry->owner->module == module && (!script || entry->owner->client_data == script)) {
        deleted++;
        entry->flags |= BIND_DELETED;
      }
    }
  }
  internal_bind_cleanup();
  return deleted;
}

static void schedule_bind_cleanup

(

)

[static]

Definition at line 60 of file binds.c.

References garbage_add(), GARBAGE_ONCE, internal_bind_cleanup(), and NULL.

Referenced by bind_entry_del(), and bind_table_del().

{
  garbage_add(internal_bind_cleanup, NULL, GARBAGE_ONCE);
}

---

Variable Documentation

bind_table_t* bind_table_list_head = NULL [static]

Definition at line 27 of file binds.c.

const char rcsid[] = "$Id: binds.c,v 1.30 2007-01-13 12:23:39 sven Exp $" [static]

Definition at line 21 of file binds.c.