lib/eggdrop/users.c File Reference

#include <eggdrop/eggdrop.h>

Go to the source code of this file.

Data Structures
struct	walker_info_t
struct	cmd_match_data_t
Defines
#define	BAD_HANDLE_CHARS   " *?@:"
Functions
static user_t *	real_user_new (const char *handle, int uid)
static int	user_get_uid ()
static int	cache_check_add (const void *key, void *dataptr, void *client_data)
static int	cache_check_del (const void *key, void *dataptr, void *client_data)
static int	cache_rand_cleanup (const char *event)
static int	cache_user_del (user_t *u, const char *ircmask)
static void	append_setting (user_t *u, const char *chan, const char *flag_str, xml_node_t *extended)
static int	userlist_delete_walker (const void *key, void *dataptr, void *client_data)
int	user_init (void)
int	user_shutdown (void)
void	user_walk (hash_table_node_func callback, void *data)
int	user_load (const char *fname)
static int	save_walker (const void *key, void *dataptr, void *param)
static int	unlink_walker (const void *key, void *dataptr, void *param)
int	user_save (const char *fname)
const char *	user_invalid_handle (const char *handle)
user_t *	user_new (const char *handle)
static int	user_really_delete (void *client_data)
int	user_delete (user_t *u)
user_t *	user_lookup_by_handle (const char *handle)
user_t *	user_lookup_authed (const char *handle, const char *pass)
user_t *	user_lookup_by_uid (int uid)
user_t *	user_lookup_by_irchost_nocache (const char *irchost)
user_t *	user_lookup_by_irchost (const char *irchost)
int	user_add_ircmask (user_t *u, const char *ircmask)
int	user_del_ircmask (user_t *u, const char *ircmask)
static int	get_flags (user_t *u, const char *chan, flags_t **flags)
int	user_get_flags (user_t *u, const char *chan, flags_t *flags)
static int	check_flag_change (user_t *u, const char *chan, flags_t *oldflags, flags_t *newflags)
int	user_set_flags (user_t *u, const char *chan, flags_t *flags)
int	user_set_flags_str (user_t *u, const char *chan, const char *flags)
static xml_node_t *	find_setting (user_t *u, const char *chan, const char *name, int create)
int	user_get_setting (user_t *u, const char *chan, const char *setting, char **valueptr)
int	user_set_setting (user_t *u, const char *chan, const char *setting, const char *value)
int	user_has_pass (user_t *u)
int	user_check_pass (user_t *u, const char *pass)
int	user_set_pass (user_t *u, const char *pass)
int	user_count ()
int	user_rand_pass (char *buf, int bufsize)
int	user_check_flags (user_t *u, const char *chan, flags_t *flags)
int	user_check_flags_str (user_t *u, const char *chan, const char *flags)
int	user_check_partial_flags (user_t *u, const char *chan, flags_t *flags)
int	user_check_partial_flags_str (user_t *u, const char *chan, const char *flags)
int	user_change_handle (user_t *u, const char *newhandle)
static int	ircmask_matches_user (user_t *u, const char *wild)
static int	attr_matches_user (user_t *u, cmd_match_data_t *mdata)
static int	callback_match_attr (const char *key, char **data, cmd_match_data_t *mdata)
static int	callback_match_ircmask (const char *key, char **data, cmd_match_data_t *mdata)
int	partyline_cmd_match_ircmask (void *p, const char *mask, long start, long limit)
int	partyline_cmd_match_attr (void *p, const char *attr, const char *chan, long start, long limit)
Variables
static const char	rcsid [] = "$Id: users.c,v 1.56 2007-05-10 00:25:07 sven Exp $"
static int	g_uid = 1
static int	uid_wraparound = 0
static int	nusers = 0
static hash_table_t *	irchost_cache_ht = NULL
static hash_table_t *	handle_ht = NULL
static hash_table_t *	uid_ht = NULL
static ircmask_list_t	ircmask_list = {NULL}
static bind_table_t *	BT_uflags = NULL
static bind_table_t *	BT_uset = NULL
static bind_table_t *	BT_udelete = NULL

---

Define Documentation

#define BAD_HANDLE_CHARS   " *?@:"

Definition at line 46 of file users.c.

Referenced by user_invalid_handle().

---

Function Documentation

static void append_setting	(	user_t *	u,
		const char *	chan,
		const char *	flag_str,
		xml_node_t *	extended
	)			[static]

Definition at line 656 of file users.c.

References flags_t::builtin, user_setting_t::chan, user_setting_t::extended, flag_from_str(), user::flags, user_setting_t::flags, xml_node::name, user::nsettings, user::settings, USER_BOT, xml_node_new(), and xml_node_unlink().

Referenced by find_setting(), user_load(), user_set_flags(), and user_set_flags_str().

{
  user_setting_t *setting;
  u->settings = realloc(u->settings, sizeof(*u->settings) * (u->nsettings+1));
  setting = u->settings + u->nsettings;
  u->nsettings++;
  memset(setting, 0, sizeof(*setting));
  if (chan) setting->chan = strdup(chan);
  if (flag_str) flag_from_str(&setting->flags, flag_str);
  if (!chan && setting->flags.builtin & 2) u->flags |= USER_BOT;
  if (extended) {
    xml_node_unlink(extended);
    setting->extended = extended;
  }
  else {
    setting->extended = xml_node_new();
    setting->extended->name = strdup("extended");
  }
}

static int attr_matches_user	(	user_t *	u,
		cmd_match_data_t *	mdata
	)			[static]

Definition at line 853 of file users.c.

References flags_t::builtin, cmd_match_data_t::channel, cmd_match_data_t::data, flag_match_partial(), flag_match_subset(), cmd_match_data_t::musthave, cmd_match_data_t::mustnothave, NULL, flags_t::udef, and user_get_flags().

Referenced by callback_match_attr().

{
  int matched = 0, haschanflags = 0;
  flags_t globflags, chanflags;

  chanflags.builtin = chanflags.udef = 0;

  if (user_get_flags(u, NULL, &globflags))
    return 0;

  if (mdata->channel) {
    haschanflags = !user_get_flags(u, mdata->channel, &chanflags);
    if (!haschanflags)
      return 0;
  }

  if ((mdata->musthave[0].builtin | mdata->musthave[0].udef) && /* Non empty needed flags */
    flag_match_subset(&mdata->musthave[0], &globflags) && /* ..AND they match */
    (!(mdata->mustnothave[0].builtin | mdata->mustnothave[0].udef) || /* AND (empty forbiden flags */
    !flag_match_partial(&globflags, &mdata->mustnothave[0])) /* OR forbiden flags don't match) */
    )
    matched = 1;

  if (mdata->data) { /* mdata->data points to '|' or '&' if it existed,
        which means channel flags are needed too */
    int tmpyes = mdata->musthave[1].builtin | mdata->musthave[1].udef;
    int tmpnot = mdata->mustnothave[1].builtin | mdata->mustnothave[1].udef;
    if (*mdata->data == '|') {

      return (matched || /* Either we already matched OR .. */
        ((tmpyes && flag_match_subset(&mdata->musthave[1], &chanflags)) && /*Non-empty needed
                        flags match, AND */
        (!tmpnot || !flag_match_partial(&chanflags, &mdata->mustnothave[1]))) /* There are no
                          forbidden flags OR
                          they don't match */
        );
    }
    else if (*mdata->data == '&')
      return (matched && /* Global flags match AND .. */
        ((tmpyes && flag_match_subset(&mdata->musthave[1], &chanflags)) &&
        (!tmpnot || !flag_match_partial(&chanflags, &mdata->mustnothave[1])))
        );
    else
      return 0;
  }

  return matched;
}

static int cache_check_add	(	const void *	key,
		void *	dataptr,
		void *	client_data
	)			[static]

Definition at line 443 of file users.c.

References walker_info_t::ircmask, user::ircmasks, user::nircmasks, walker_info_t::u, and wild_match().

Referenced by user_add_ircmask().

{
  const char *irchost = key;
  user_t *u = *(user_t **)dataptr;
  walker_info_t *info = client_data;
  int i, strength, max_strength;

  /* Get the strength of the current match. */
  max_strength = 0;
  if (u) {
    for (i = 0; i < u->nircmasks; i++) {
      strength = wild_match(u->ircmasks[i], irchost);
      if (strength > max_strength) max_strength = strength;
    }
  }

  /* And now the strength of the the new mask. */
  strength = wild_match(info->ircmask, irchost);
  if (strength > max_strength) {
    /* Ok, replace it. */
    *(user_t **)dataptr = info->u;
  }
  return(0);
}

static int cache_check_del	(	const void *	key,
		void *	dataptr,
		void *	client_data
	)			[static]

Definition at line 468 of file users.c.

References walker_info_t::entries, walker_info_t::ircmask, walker_info_t::maxentries, walker_info_t::nentries, walker_info_t::rand_delete, walker_info_t::u, and wild_match().

Referenced by cache_rand_cleanup(), and cache_user_del().

{
  const char *irchost = key;
  user_t *u = *(user_t **)dataptr;
  walker_info_t *info = client_data;

  if ((info->rand_delete && (rand() & 1)) || (!info->rand_delete && u == info->u && wild_match(info->ircmask, irchost))) {
    if (info->nentries >= info->maxentries) {
      info->maxentries = 2*info->maxentries+1;
      info->entries = realloc(info->entries, sizeof(*info->entries) * (info->maxentries+1));
    }
    info->entries[info->nentries] = irchost;
    info->nentries++;
  }
  return(0);
}

static int cache_rand_cleanup

(

const char *

event

)

[static]

Definition at line 508 of file users.c.

References cache_check_del(), walker_info_t::entries, hash_table_remove(), hash_table_walk(), walker_info_t::ircmask, LOG_MISC, walker_info_t::maxentries, walker_info_t::nentries, NULL, putlog(), walker_info_t::rand_delete, and walker_info_t::u.

Referenced by user_init().

{
  walker_info_t info;
  int i;

  /* Check irchost_cache_ht for changes in the users. */
  info.u = NULL;
  info.ircmask = NULL;
  info.entries = NULL;
  info.nentries = 0;
  info.maxentries = 0;
  info.rand_delete = 1;
  hash_table_walk(irchost_cache_ht, cache_check_del, &info);
  putlog(LOG_MISC, "*", "user_rand_cleanup: deleting %d entries from cache", info.nentries);
  for (i = 0; i < info.nentries; i++) {
    hash_table_remove(irchost_cache_ht, info.entries[i], NULL);
  }
  if (info.entries) free(info.entries);
  return(0);
}

static int cache_user_del	(	user_t *	u,
		const char *	ircmask
	)			[static]

Definition at line 485 of file users.c.

References cache_check_del(), walker_info_t::entries, hash_table_remove(), hash_table_walk(), walker_info_t::ircmask, ircmask_list_del(), walker_info_t::maxentries, walker_info_t::nentries, NULL, walker_info_t::rand_delete, and walker_info_t::u.

Referenced by user_del_ircmask(), and user_delete().

{
  walker_info_t info;
  int i;

  /* Check irchost_cache_ht for changes in the users. */
  info.u = u;
  info.ircmask = ircmask;
  info.entries = NULL;
  info.nentries = 0;
  info.maxentries = 0;
  info.rand_delete = 0;
  hash_table_walk(irchost_cache_ht, cache_check_del, &info);
  for (i = 0; i < info.nentries; i++) {
    hash_table_remove(irchost_cache_ht, info.entries[i], NULL);
  }
  if (info.entries) free(info.entries);

  /* And remove it from the ircmask_list. */
  ircmask_list_del(&ircmask_list, ircmask, u);
  return(0);
}

static int callback_match_attr	(	const char *	key,
		char **	data,
		cmd_match_data_t *	mdata
	)			[static]

Definition at line 911 of file users.c.

References _, attr_matches_user(), cmd_match_data_t::limit, partymember_printf(), cmd_match_data_t::pmember, cmd_match_data_t::start, and user_lookup_by_handle().

Referenced by partyline_cmd_match_attr().

{
  user_t *u = user_lookup_by_handle(key);

  if (!u)
    return 0;

  if (mdata->start && attr_matches_user(u, mdata)) {
    mdata->start--;
    return 0;
  }

  if (mdata->limit && attr_matches_user(u, mdata)) {
    mdata->limit--;
    partymember_printf(mdata->pmember, _("  %s"), key);
  }

  return 0;
}

static int callback_match_ircmask	(	const char *	key,
		char **	data,
		cmd_match_data_t *	mdata
	)			[static]

Definition at line 932 of file users.c.

References _, cmd_match_data_t::data, ircmask_matches_user(), cmd_match_data_t::limit, partymember_printf(), cmd_match_data_t::pmember, cmd_match_data_t::start, user_lookup_by_handle(), and wild_match().

Referenced by partyline_cmd_match_ircmask().

{
  user_t *u = user_lookup_by_handle(key);

  if (!u)
    return 0;

  if (mdata->start && (wild_match(mdata->data, key) || ircmask_matches_user(u, mdata->data))) {
    mdata->start--;
    return 0;
  }

  if (mdata->limit && (wild_match(mdata->data, key) || ircmask_matches_user(u, mdata->data))) {
    mdata->limit--;
    partymember_printf(mdata->pmember, _("  %s"), key);
  }

  return 0;
}

static int check_flag_change	(	user_t *	u,
		const char *	chan,
		flags_t *	oldflags,
		flags_t *	newflags
	)			[static]

Definition at line 594 of file users.c.

References bind_check(), BIND_RET_BREAK, flags_t::builtin, egg_msprintf(), flag_to_str(), user::flags, user::handle, NULL, USER_BOT, USER_LINKED_BOT, and USER_LINKING_BOT.

Referenced by user_set_flags(), and user_set_flags_str().

{
  char oldstr[64], newstr[64], *change;
  int r;

  if (u->flags & (USER_LINKING_BOT | USER_LINKED_BOT) && !chan && (oldflags->builtin & 2) != (newflags->builtin & 2)) return -1;
  flag_to_str(oldflags, oldstr);
  flag_to_str(newflags, newstr);
  change = egg_msprintf(NULL, 0, NULL, "%s %s %s", chan ? chan : "", oldstr, newstr);
  r = bind_check(BT_uflags, NULL, change, u->handle, chan, oldstr, newstr);
  free(change);

  /* Does a callback want to cancel this flag change? */
  if (r & BIND_RET_BREAK) return(-1);
  if (!chan) {
    if (newflags->builtin & 2) u->flags |= USER_BOT;
    else u->flags &= ~USER_BOT;
  }
  return(0);
}

static xml_node_t* find_setting	(	user_t *	u,
		const char *	chan,
		const char *	name,
		int	create
	)			[static]

Definition at line 676 of file users.c.

References append_setting(), user_setting_t::chan, user_setting_t::extended, user::nsettings, NULL, user::settings, and xml_node_lookup().

Referenced by user_get_setting(), and user_set_setting().

{
  user_setting_t *setting;
  int i = 0;

  if (chan) for (i = 1; i < u->nsettings; i++) {
    if (!strcasecmp(chan, u->settings[i].chan)) break;
  }
  if (i >= u->nsettings) {
    if (!create) return(NULL);
    append_setting(u, chan, NULL, NULL);
  }
  setting = u->settings+i;
  return xml_node_lookup(setting->extended, create, name, 0, NULL);
}

static int get_flags	(	user_t *	u,
		const char *	chan,
		flags_t **	flags
	)			[static]

Definition at line 568 of file users.c.

References user_setting_t::chan, user_setting_t::flags, user::nsettings, and user::settings.

Referenced by user_get_flags(), user_set_flags(), and user_set_flags_str().

{
  int i;

  if (!chan) i = 0;
  else {
    for (i = 1; i < u->nsettings; i++) {
      if (!strcasecmp(chan, u->settings[i].chan)) break;
    }
    if (i == u->nsettings) return(-1);
  }
  *flags = &u->settings[i].flags;
  return(0);
}

static int ircmask_matches_user	(	user_t *	u,
		const char *	wild
	)			[static]

Definition at line 842 of file users.c.

References user::ircmasks, user::nircmasks, and wild_match().

Referenced by callback_match_ircmask().

{
  int i;

  for (i = 0; i < u->nircmasks; i++)
    if (wild_match(wild, u->ircmasks[i]))
      return 1;
  return 0;
}

int partyline_cmd_match_attr	(	void *	p,
		const char *	attr,
		const char *	chan,
		long	start,
		long	limit
	)

Definition at line 969 of file users.c.

References flags_t::builtin, callback_match_attr(), cmd_match_data_t::channel, cmd_match_data_t::data, flag_merge_str(), hash_table_walk(), cmd_match_data_t::limit, cmd_match_data_t::musthave, cmd_match_data_t::mustnothave, NULL, cmd_match_data_t::pmember, cmd_match_data_t::start, and flags_t::udef.

Referenced by party_matchattr().

{
  cmd_match_data_t mdata;
  int plsmns = 1, globchan = 0;
  char flagshack[] = "+ "; /* Hack to allow us to use flag_merge_str */

  mdata.start = start;
  mdata.limit = limit;
/* FIXME - Once we sort #includes, 'p' should be partymember_t in function declaration */
  mdata.pmember = (partymember_t *)p;
  mdata.data = NULL;
  mdata.channel = chan;
  mdata.musthave[0].builtin = mdata.musthave[0].udef = 0;
  mdata.mustnothave[0].builtin = mdata.mustnothave[0].udef = 0;
  mdata.musthave[1].builtin = mdata.musthave[1].udef = 0;
  mdata.mustnothave[1].builtin = mdata.mustnothave[1].udef = 0;

  while (*attr) {
    switch (*attr) {
      case '+':
        plsmns = 1;
        break;
      case '-':
        plsmns = 0;
        break;
      case '&':
      case '|':
        if (globchan == 0) { /* Consider only the first & or | */
          globchan++;
          mdata.data = attr;
        }
        break;
      default:
        flagshack[1] = *attr;
        flag_merge_str(plsmns ? &mdata.musthave[globchan] :
              &mdata.mustnothave[globchan], flagshack);
        break;
    }
    attr++;
  }

  hash_table_walk(handle_ht, (hash_table_node_func)callback_match_attr, &mdata);

  return 0;
}

int partyline_cmd_match_ircmask	(	void *	p,
		const char *	mask,
		long	start,
		long	limit
	)

Definition at line 953 of file users.c.

References callback_match_ircmask(), cmd_match_data_t::data, hash_table_walk(), cmd_match_data_t::limit, cmd_match_data_t::pmember, and cmd_match_data_t::start.

Referenced by party_matchwild().

{
  cmd_match_data_t mdata;

  mdata.start = start;
  mdata.limit = limit;
/* FIXME - Once we sort #includes, 'p' should be partymember_t in function declaration */
  mdata.pmember = (partymember_t *)p;
  mdata.data = mask;

  hash_table_walk(handle_ht, (hash_table_node_func)callback_match_ircmask, &mdata);

  return 0;
}

static user_t * real_user_new	(	const char *	handle,
		int	uid
	)			[static]

Definition at line 311 of file users.c.

References user::handle, hash_table_insert(), NULL, nusers, user::uid, user_get_uid(), and user_invalid_handle().

Referenced by user_load(), and user_new().

{
  user_t *u;

  /* Make sure the handle is valid. */
  if (user_invalid_handle(handle)) return(NULL);

  u = calloc(1, sizeof(*u));
  u->handle = strdup(handle);
  if (!uid) uid = user_get_uid();
  u->uid = uid;

  hash_table_insert(handle_ht, u->handle, u);
  hash_table_insert(uid_ht, (void *)u->uid, u);
  nusers++;
  return(u);
}

static int save_walker	(	const void *	key,
		void *	dataptr,
		void *	param
	)			[static]

Definition at line 222 of file users.c.

References user_setting_t::chan, user_setting_t::extended, flag_to_str(), user_setting_t::flags, user::handle, user::ircmasks, xml_node::name, user::nircmasks, user::nsettings, user::settings, user::uid, xml_node_append(), xml_node_new(), xml_node_set_int(), and xml_node_set_str().

Referenced by user_save().

{
  xml_node_t *root = param;
  user_t *u = *(user_t **)dataptr;
  user_setting_t *setting;
  xml_node_t *user_node, *setting_node;
  int i;
  char flag_str[128];

  user_node = xml_node_new();
  user_node->name = strdup("user");
  xml_node_set_str(u->handle, user_node, "handle", 0, 0);
  xml_node_set_int(u->uid, user_node, "uid", 0, 0);
  for (i = 0; i < u->nircmasks; i++) xml_node_set_str(u->ircmasks[i], user_node, "ircmask", i, 0);
  for (i = 0; i < u->nsettings; i++) {
    setting = u->settings+i;
    setting_node = xml_node_new();
    setting_node->name = strdup("setting");
    if (setting->chan) xml_node_set_str(setting->chan, setting_node, "chan", 0, 0);
    flag_to_str(&u->settings[i].flags, flag_str);
    xml_node_set_str(flag_str, setting_node, "flags", 0, 0);
    xml_node_append(setting_node, u->settings[i].extended);
    xml_node_append(user_node, setting_node);
  }
  xml_node_append(root, user_node);
  return(0);
}

static int unlink_walker	(	const void *	key,
		void *	dataptr,
		void *	param
	)			[static]

Definition at line 250 of file users.c.

References user_setting_t::extended, user::nsettings, user::settings, and xml_node_unlink().

Referenced by user_save().

{
  user_t *u = *(user_t **)dataptr;
  int i;

  for (i = 0; i < u->nsettings; i++) {
    xml_node_unlink(u->settings[i].extended);
  }
  return(0);
}

int user_add_ircmask	(	user_t *	u,
		const char *	ircmask
	)

Definition at line 529 of file users.c.

References cache_check_add(), hash_table_walk(), walker_info_t::ircmask, ircmask_list_add(), user::ircmasks, user::nircmasks, and walker_info_t::u.

Referenced by AddMask(), and party_plus_host().

{
  walker_info_t info;

  /* Add the ircmask to the user entry. */
  u->ircmasks = (char **)realloc(u->ircmasks, sizeof(char *) * (u->nircmasks+1));
  u->ircmasks[u->nircmasks] = strdup(ircmask);
  u->nircmasks++;

  /* Put it in the big list. */
  ircmask_list_add(&ircmask_list, ircmask, u);

  /* Check irchost_cache_ht for changes in the users. */
  info.u = u;
  info.ircmask = ircmask;
  hash_table_walk(irchost_cache_ht, cache_check_add, &info);
  return(0);
}

int user_change_handle	(	user_t *	u,
		const char *	newhandle
	)

Definition at line 824 of file users.c.

References user::handle, hash_table_insert(), hash_table_remove(), NULL, partymember_lookup(), partymember_set_nick(), and user_invalid_handle().

Referenced by party_chhandle().

{
  char *old = u->handle;
  partymember_t *p = NULL;

  if (user_invalid_handle(newhandle)) return 1;
  hash_table_remove(handle_ht, u->handle, NULL);
  u->handle = strdup(newhandle);
  hash_table_insert(handle_ht, u->handle, u);

  while ((p = partymember_lookup(old, NULL, -1))) {
    partymember_set_nick(p, u->handle);
  }

  free(u->handle);
  return(0);
}

int user_check_flags	(	user_t *	u,
		const char *	chan,
		flags_t *	flags
	)

Definition at line 792 of file users.c.

References flag_match_subset(), and user_get_flags().

Referenced by user_check_flags_str().

{
  flags_t f;

  user_get_flags(u, chan, &f);
  return flag_match_subset(flags, &f);
}

int user_check_flags_str	(	user_t *	u,
		const char *	chan,
		const char *	flags
	)

Definition at line 800 of file users.c.

References flag_from_str(), and user_check_flags().

Referenced by party_chanmembermode().

{
  flags_t f;

  flag_from_str(&f, flags);
  return user_check_flags(u, chan, &f);
}

int user_check_partial_flags	(	user_t *	u,
		const char *	chan,
		flags_t *	flags
	)

Definition at line 808 of file users.c.

References flag_match_partial(), and user_get_flags().

Referenced by user_check_partial_flags_str().

{
  flags_t f;

  user_get_flags(u, chan, &f);
  return flag_match_partial(flags, &f);
}

int user_check_partial_flags_str	(	user_t *	u,
		const char *	chan,
		const char *	flags
	)

Definition at line 816 of file users.c.

References flag_from_str(), and user_check_partial_flags().

Referenced by party_chanmembermode().

{
  flags_t f;

  flag_from_str(&f, flags);
  return user_check_partial_flags(u, chan, &f);
}

int user_check_pass	(	user_t *	u,
		const char *	pass
	)

Definition at line 725 of file users.c.

References MD5_Final(), MD5_Hex(), MD5_Init(), MD5_Update(), NULL, and user_get_setting().

Referenced by CheckPass(), and user_lookup_authed().

{
  char *hash, *salt, testhex[33];
  unsigned char test[16];
  MD5_CTX ctx;

  user_get_setting(u, NULL, "pass", &hash);
  user_get_setting(u, NULL, "salt", &salt);
  if (!hash || !salt || !strcmp(hash, "none")) return(0);

  MD5_Init(&ctx);
  MD5_Update(&ctx, salt, strlen(salt));
  MD5_Update(&ctx, pass, strlen(pass));
  MD5_Final(test, &ctx);
  MD5_Hex(test, testhex);
  return !strcasecmp(testhex, hash);
}

int user_count

(

)

Definition at line 769 of file users.c.

References nusers.

Referenced by create_userfile().

{
  return(nusers);
}

int user_del_ircmask	(	user_t *	u,
		const char *	ircmask
	)

Definition at line 548 of file users.c.

References cache_user_del(), user::ircmasks, and user::nircmasks.

Referenced by DelMask(), and party_minus_host().

{
  int i;

  /* Find the ircmask in the user entry. */
  for (i = 0; i < u->nircmasks; i++) {
    if (!strcasecmp(u->ircmasks[i], ircmask)) break;
  }
  if (i == u->nircmasks) return(-1);

  /* Get rid of it. */
  memmove(u->ircmasks+i, u->ircmasks+i+1, sizeof(char *) * (u->nircmasks - i - 1));
  u->nircmasks--;

  /* Delete matching entries of this user in the host cache. */
  cache_user_del(u, ircmask);

  return(0);
}

int user_delete

(

user_t *

u

)

Definition at line 370 of file users.c.

References bind_check(), cache_user_del(), user::flags, garbage_add(), user::handle, hash_table_remove(), ircmask_list_del(), user::ircmasks, user::nircmasks, NULL, nusers, user::uid, USER_DELETED, USER_LINKED_BOT, USER_LINKING_BOT, and user_really_delete().

Referenced by Delete(), party_minus_bot(), party_minus_obot(), party_minus_user(), terminal_shutdown(), and userlist_delete_walker().

{
  int i;

  if (!u || (u->flags & (USER_DELETED | USER_LINKING_BOT | USER_LINKED_BOT))) return(-1);

  nusers--;
  hash_table_remove(handle_ht, u->handle, NULL);
  hash_table_remove(uid_ht, (void *)u->uid, NULL);
  cache_user_del(u, "*");
  for (i = 0; i < u->nircmasks; i++) ircmask_list_del(&ircmask_list, u->ircmasks[i], u);
  u->flags |= USER_DELETED;
  bind_check(BT_udelete, NULL, NULL, u);
  garbage_add(user_really_delete, u, 0);
  return(0);
}

int user_get_flags	(	user_t *	u,
		const char *	chan,
		flags_t *	flags
	)

Definition at line 583 of file users.c.

References flags_t::builtin, get_flags(), and flags_t::udef.

Referenced by attr_matches_user(), GetFlags(), MatchFlags(), MatchFlagsOr(), party_chattr(), party_whois(), script_getflags(), script_matchflags(), user_check_flags(), and user_check_partial_flags().

{
  flags_t *uflags;

  if (get_flags(u, chan, &uflags)) return(-1);

  flags->builtin = uflags->builtin;
  flags->udef = uflags->udef;
  return(0);
}

int user_get_setting	(	user_t *	u,
		const char *	chan,
		const char *	setting,
		char **	valueptr
	)

Definition at line 692 of file users.c.

References find_setting(), NULL, and xml_node_get_str().

Referenced by botnet_find_min(), botnet_link(), botnet_link_prio(), do_link(), Get(), got_join(), party_minus_bot(), party_minus_obot(), party_whois(), recving_login(), script_user_get(), user_check_pass(), user_has_pass(), and user_set_pass().

{
  xml_node_t *node = find_setting(u, chan, setting, 0);

  return xml_node_get_str(valueptr, node, NULL);
}

static int user_get_uid

(

)

[static]

Definition at line 280 of file users.c.

References g_uid, hash_table_find(), and uid_wraparound.

Referenced by real_user_new(), and user_new().

{
  user_t *u;
  int uid;

  if (g_uid <= 0) {
    g_uid = 1;
    uid_wraparound++;
  }

  /* If we've wrapped around on uids, we need to search for a free one. */
  if (uid_wraparound) {
    while (!hash_table_find(uid_ht, (void *)g_uid, &u)) g_uid++;
  }

  uid = g_uid;
  g_uid++;
  return(uid);
}

int user_has_pass

(

user_t *

u

)

Definition at line 715 of file users.c.

References NULL, and user_get_setting().

Referenced by HasPass().

{
  char *hash, *salt;

  user_get_setting(u, NULL, "pass", &hash);
  user_get_setting(u, NULL, "salt", &salt);
  if (hash && salt && strcmp(hash, "none")) return(1);
  return(0);
}

int user_init

(

void

)

Definition at line 128 of file users.c.

References bind_add_simple(), BIND_STACKABLE, bind_table_add(), BTN_USER_CHANGE_FLAGS, BTN_USER_CHANGE_SETTINGS, BTN_USER_DELETE, cache_rand_cleanup(), hash_table_create(), HASH_TABLE_FREE_KEY, HASH_TABLE_INTS, HASH_TABLE_STRINGS, HOST_HASH_SIZE, MATCH_MASK, MATCH_NONE, NULL, and USER_HASH_SIZE.

Referenced by eggdrop_init().

{

  /* Create hash tables. */
  handle_ht = hash_table_create(NULL, NULL, USER_HASH_SIZE, HASH_TABLE_STRINGS);
  uid_ht = hash_table_create(NULL, NULL, USER_HASH_SIZE, HASH_TABLE_INTS);
  irchost_cache_ht = hash_table_create(NULL, NULL, HOST_HASH_SIZE, HASH_TABLE_STRINGS | HASH_TABLE_FREE_KEY);

  /* And bind tables. */
  BT_uflags = bind_table_add(BTN_USER_CHANGE_FLAGS, 4, "ssss", MATCH_MASK, BIND_STACKABLE); /* DDD  */
  BT_uset = bind_table_add(BTN_USER_CHANGE_SETTINGS, 4, "ssss", MATCH_MASK, BIND_STACKABLE);  /* DDD  */
  BT_udelete = bind_table_add(BTN_USER_DELETE, 1, "U", MATCH_NONE, BIND_STACKABLE); /* DDD  */

  /* Add binds. */
  bind_add_simple("event", NULL, "hourly", cache_rand_cleanup);

  return(0);
}

const char* user_invalid_handle

(

const char *

handle

)

Definition at line 300 of file users.c.

References _, BAD_HANDLE_CHARS, NULL, and user_lookup_by_handle().

Referenced by party_chhandle(), party_plus_user(), real_user_new(), and user_change_handle().

{
  if (user_lookup_by_handle(handle)) return _("Handle already exists!");
  for (; *handle; ++handle) {
    if (*handle < 32 || strchr(BAD_HANDLE_CHARS, *handle)) {
      return _("Handle contains invalid characters!");
    }
  }
  return NULL;
}

int user_load

(

const char *

fname

)

Definition at line 170 of file users.c.

References _, append_setting(), g_uid, ircmask_list_add(), user::ircmasks, LOG_MISC, xml_node::next_sibling, user::nircmasks, NULL, nusers, putlog(), real_user_new(), uid_wraparound, xml_doc_delete(), xml_last_error(), xml_node_get_vars(), xml_node_lookup(), xml_node_str(), and xml_parse_file().

Referenced by core_init().

{
  int uid;
  xml_node_t *root, *user_node, *ircmask_node, *setting_node, *extended_node;
  char *handle, *ircmask, *chan, *flag_str;
  user_t *u;

  if (!(root = xml_parse_file(fname))) {
    putlog(LOG_MISC, "*", _("Failed to load userfile '%s': %s"), fname, xml_last_error());
    return -1;
  }

  xml_node_get_vars(root, "ii", "next_uid", &uid, "uid_wraparound", &uid_wraparound);
  g_uid = uid;

  user_node = xml_node_lookup(root, 0, "user", 0, 0);
  for (; user_node; user_node = user_node->next_sibling) {
    /* The only required user fields are 'handle' and 'uid'. */
    xml_node_get_vars(user_node, "sinn", "handle", &handle, "uid", &uid, "ircmask", &ircmask_node, "setting", &setting_node);

    if (!handle || !uid) continue;
    u = real_user_new(handle, uid);

    /* User already exists? */
    if (!u) continue;

    /* Irc masks. */
    for (; ircmask_node; ircmask_node = ircmask_node->next_sibling) {
      ircmask = xml_node_str(ircmask_node, NULL);
      if (!ircmask) continue;
      u->ircmasks = realloc(u->ircmasks, sizeof(char *) * (u->nircmasks+1));
      u->ircmasks[u->nircmasks] = strdup(ircmask);
      u->nircmasks++;
      ircmask_list_add(&ircmask_list, ircmask, u);
    }

    /* Settings. */
    /* They have to have at least 1 setting, the global one. */
    if (!setting_node) append_setting(u, NULL, NULL, NULL);
    for (; setting_node; setting_node = setting_node->next_sibling) {
      xml_node_get_vars(setting_node, "ssn", "chan", &chan, "flags", &flag_str, "extended", &extended_node);
      append_setting(u, chan, flag_str, extended_node);
    }
  }
  xml_doc_delete(root);

  if (nusers == 1) putlog(LOG_MISC, "*", _("Loaded 1 user"));
  else putlog(LOG_MISC, "*", _("Loaded %d users"), nusers);

  return(0);
}

user_t* user_lookup_authed	(	const char *	handle,
		const char *	pass
	)

Definition at line 400 of file users.c.

References NULL, user_check_pass(), and user_lookup_by_handle().

Referenced by dcc_on_read(), irc_on_read(), and telnet_on_read().

{
  user_t *u = user_lookup_by_handle(handle);
  if (!u) return(NULL);
  if (user_check_pass(u, pass)) return(u);
  return(NULL);
}

user_t* user_lookup_by_handle

(

const char *

handle

)

Definition at line 392 of file users.c.

References hash_table_find(), and NULL.

Referenced by botnet_link(), callback_match_attr(), callback_match_ircmask(), Egguser_New(), js_to_c_var(), party_chattr(), party_chhandle(), party_chpass(), party_minus_bot(), party_minus_host(), party_minus_obot(), party_minus_user(), party_plus_host(), party_whois(), perl_to_c_var(), recving_login(), script_validhandle(), tcl_to_c_var(), terminal_init(), user_invalid_handle(), and user_lookup_authed().

{
  user_t *u = NULL;
  if (handle == NULL) return NULL;
  hash_table_find(handle_ht, handle, &u);
  return(u);
}

user_t* user_lookup_by_irchost

(

const char *

irchost

)

Definition at line 428 of file users.c.

References hash_table_find(), hash_table_insert(), and ircmask_list_find().

Referenced by party_channels(), process_results(), and server_parse_input().

{
  user_t *u;

  /* Check the irchost cache. */
  if (!hash_table_find(irchost_cache_ht, irchost, &u)) return(u);

  /* Look for a match in the ircmask list. */
  ircmask_list_find(&ircmask_list, irchost, &u);

  /* Cache it, even if it's null (to prevent future lookups). */
  hash_table_insert(irchost_cache_ht, strdup(irchost), u);
  return(u);
}

user_t* user_lookup_by_irchost_nocache

(

const char *

irchost

)

Definition at line 416 of file users.c.

References hash_table_find(), and ircmask_list_find().

Referenced by goterror(), and script_user_find().

{
  user_t *u;

  /* Check the ircmask cache. */
  if (!hash_table_find(irchost_cache_ht, irchost, &u)) return(u);

  /* Look for a match in the ircmask list. We don't cache the result. */
  ircmask_list_find(&ircmask_list, irchost, &u);
  return(u);
}

user_t* user_lookup_by_uid

(

int

uid

)

Definition at line 408 of file users.c.

References hash_table_find(), and NULL.

Referenced by Egguser_New(), script_uid_to_handle(), and script_validuid().

{
  user_t *u = NULL;

  hash_table_find(uid_ht, (void *)uid, &u);
  return(u);
}

user_t* user_new

(

const char *

handle

)

Definition at line 329 of file users.c.

References user_setting_t::extended, xml_node::name, user::nsettings, NULL, real_user_new(), user::settings, user_get_uid(), and xml_node_new().

Referenced by create_userfile(), party_plus_bot(), party_plus_obot(), party_plus_user(), script_adduser(), and terminal_init().

{
  int uid;
  user_t *u;

  uid = user_get_uid();
  u = real_user_new(handle, uid);
  if (!u) return(NULL);

  /* All users have the global setting by default. */
  u->settings = calloc(1, sizeof(*u->settings));
  u->nsettings = 1;
  u->settings[0].extended = xml_node_new();
  u->settings[0].extended->name = strdup("extended");

  return(u);
}

int user_rand_pass	(	char *	buf,
		int	bufsize
	)

Definition at line 775 of file users.c.

Referenced by create_userfile(), and user_set_pass().

{
  int i, c;

  bufsize--;
  if (!buf || bufsize <= 0) return(-1);
  for (i = 0; i < bufsize; i++) {
    c = (random() + (random() >> 16) + (random() >> 24)) % 62;
    if (c < 10) c += 48;  /* Digits. */
    else if (c < 36) c += 55; /* Uppercase. */
    else c += 61; /* Lowercase. */
    buf[i] = c;
  }
  buf[i] = 0;
  return(0);
}

static int user_really_delete

(

void *

client_data

)

[static]

Definition at line 347 of file users.c.

References user_setting_t::chan, user_setting_t::extended, user::handle, user::ircmasks, user::nircmasks, user::nsettings, user::settings, and xml_node_delete().

Referenced by user_delete().

{
  int i;
  user_t *u = client_data;
  user_setting_t *setting;

  /* Free the ircmasks. */
  for (i = 0; i < u->nircmasks; i++) free(u->ircmasks[i]);
  if (u->ircmasks) free(u->ircmasks);

  /* And all of the settings. */
  for (i = 0; i < u->nsettings; i++) {
    setting = u->settings+i;
    xml_node_delete(setting->extended);
    if (setting->chan) free(setting->chan);
  }
  if (u->settings) free(u->settings);
  if (u->handle) free(u->handle);

  free(u);
  return(0);
}

int user_save

(

const char *

fname

)

Definition at line 261 of file users.c.

References g_uid, hash_table_walk(), xml_node::name, NULL, save_walker(), uid_wraparound, unlink_walker(), XML_INDENT, xml_node_delete(), xml_node_new(), xml_node_set_int(), and xml_save_file().

Referenced by core_shutdown_or_restart(), create_userfile(), party_save(), and script_user_save().

{
  xml_node_t *root;

  root = xml_node_new();
  root->name = strdup("users");

  xml_node_set_int(g_uid, root, "next_uid", 0, 0);
  xml_node_set_int(uid_wraparound, root, "uid_wraparound", 0, 0);
  hash_table_walk(uid_ht, save_walker, root);

  xml_save_file((fname) ? fname : "users.xml", root, XML_INDENT);

  hash_table_walk(uid_ht, unlink_walker, NULL);

  xml_node_delete(root);
  return(0);
}

int user_set_flags	(	user_t *	u,
		const char *	chan,
		flags_t *	flags
	)

Definition at line 615 of file users.c.

References append_setting(), flags_t::builtin, channel_sanity_check(), check_flag_change(), get_flags(), global_sanity_check(), NULL, and flags_t::udef.

{
  flags_t *oldflags, newflags;

  if (get_flags(u, chan, &oldflags)) {
    append_setting(u, chan, NULL, NULL);
    if (get_flags(u, chan, &oldflags)) return -1;
  }
  newflags.builtin = flags->builtin;
  newflags.udef = flags->udef;
  if (check_flag_change(u, chan, oldflags, &newflags)) return(0);
  oldflags->builtin = newflags.builtin;
  oldflags->udef = newflags.udef;
  if (chan)
    channel_sanity_check(oldflags);
  else
    global_sanity_check(oldflags);
  return(0);
}

int user_set_flags_str	(	user_t *	u,
		const char *	chan,
		const char *	flags
	)

Definition at line 635 of file users.c.

References append_setting(), flags_t::builtin, channel_sanity_check(), check_flag_change(), flag_merge_str(), get_flags(), global_sanity_check(), NULL, and flags_t::udef.

Referenced by create_userfile(), party_chattr(), party_plus_bot(), party_plus_obot(), script_setflags(), SetFlags(), and terminal_init().

{
  flags_t *oldflags, newflags;

  if (get_flags(u, chan, &oldflags)) {
    append_setting(u, chan, NULL, NULL);
    if (get_flags(u, chan, &oldflags)) return(-1);
  }
  newflags.builtin = oldflags->builtin;
  newflags.udef = oldflags->udef;
  flag_merge_str(&newflags, flags);
  if (check_flag_change(u, chan, oldflags, &newflags)) return(0);
  oldflags->builtin = newflags.builtin;
  oldflags->udef = newflags.udef;
  if (chan)
    channel_sanity_check(oldflags);
  else
    global_sanity_check(oldflags);
  return(0);
}

int user_set_pass	(	user_t *	u,
		const char *	pass
	)

Definition at line 743 of file users.c.

References MD5_Final(), MD5_Hex(), MD5_Init(), MD5_Update(), NULL, user_get_setting(), user_rand_pass(), and user_set_setting().

Referenced by create_userfile(), party_chpass(), party_newpass(), and SetPass().

{
  char hashhex[33], *salt, new_salt[33];
  unsigned char hash[16];
  MD5_CTX ctx;

  user_get_setting(u, NULL, "salt", &salt);
  if (!salt) {
    salt = new_salt;
    user_rand_pass(salt, sizeof(new_salt));
    user_set_setting(u, NULL, "salt", salt);
  }

  if (!pass || !*pass) {
    user_set_setting(u, NULL, "pass", "none");
    return(1);
  }
  MD5_Init(&ctx);
  MD5_Update(&ctx, salt, strlen(salt));
  MD5_Update(&ctx, pass, strlen(pass));
  MD5_Final(hash, &ctx);
  MD5_Hex(hash, hashhex);
  user_set_setting(u, NULL, "pass", hashhex);
  return(0);
}

int user_set_setting	(	user_t *	u,
		const char *	chan,
		const char *	setting,
		const char *	value
	)

Definition at line 699 of file users.c.

References bind_check(), BIND_RET_BREAK, egg_msprintf(), find_setting(), user::handle, NULL, and xml_node_set_str().

Referenced by got_handshake(), party_plus_bot(), party_plus_obot(), script_user_set(), Set(), and user_set_pass().

{
  int r;
  char *change, buf[64];
  xml_node_t *node;

  change = egg_msprintf(buf, sizeof(buf), NULL, "%s %s", chan ? chan : "", setting);
  r = bind_check(BT_uset, NULL, change, u->handle, chan, setting, value);
  if (change != buf) free(change);

  if (r & BIND_RET_BREAK) return(0);

  node = find_setting(u, chan, setting, 1);
  return xml_node_set_str(value, node, NULL);
}

int user_shutdown

(

void

)

Definition at line 147 of file users.c.

References bind_table_del(), garbage_run(), hash_table_delete(), hash_table_walk(), NULL, and userlist_delete_walker().

Referenced by eggdrop_shutdown().

{
  hash_table_walk(uid_ht, userlist_delete_walker, NULL);

  /* flush any pending user delete events */
  garbage_run();

  bind_table_del(BT_udelete);
  bind_table_del(BT_uset);
  bind_table_del(BT_uflags);

  hash_table_delete(irchost_cache_ht);
  hash_table_delete(uid_ht);
  hash_table_delete(handle_ht);

  return (0);
}

void user_walk	(	hash_table_node_func	callback,
		void *	data
	)

Definition at line 165 of file users.c.

References hash_table_walk().

Referenced by botnet_autolink().

{
  hash_table_walk(uid_ht, callback, data);
}

static int userlist_delete_walker	(	const void *	key,
		void *	dataptr,
		void *	client_data
	)			[static]

Definition at line 387 of file users.c.

References user_delete().

Referenced by user_shutdown().

{
  return user_delete(*(user_t **)dataptr);
}

---

Variable Documentation

bind_table_t* BT_udelete = NULL [static]

Bind:

This flag is triggered every time a user is deleted.

Name:

udelete

Flags:

ignored

Match:

Nothing.

Parameters:

user

The deleted user.

Note:

This bind is stackable.

Returns:

Any return value will be ignored.

Bug:

The flags are ignored, nothing is matched, the bind is triggered after the user was deleted.

Definition at line 116 of file users.c.

bind_table_t* BT_uflags = NULL [static]

Bind:

This flag is triggered every time the flags of a user are changed.

Name:

uflags

Flags:

ignored

Match:

"channel oldflags newflags"

Parameters:

	string	The user's handle.
	string	The channel.
	string	The old flags.
	string	The new flags.

Note:

This bind is stackable.

Returns:

The return value is broken.

Bug:

The flags are ignored, the return value is treated as if the bind is breakable, the user is passed as a string.

Definition at line 83 of file users.c.

bind_table_t* BT_uset = NULL [static]

Bind:

This flag is triggered every time a user's settings are changed.

Name:

uset

Flags:

ignored

Match:

"channel setting"

Parameters:

	string	The user's handle.
	string	The channel.
	string	The setting.
	string	The value.

Note:

This bind is stackable.

Returns:

The return value is broken.

Bug:

The flags are ignored, the return value is treated as if the bind is breakable, the user is passed as a string.

Definition at line 101 of file users.c.

int g_uid = 1 [static]

Definition at line 50 of file users.c.

Referenced by user_get_uid(), user_load(), and user_save().

hash_table_t* handle_ht = NULL [static]

Definition at line 59 of file users.c.

hash_table_t* irchost_cache_ht = NULL [static]

Definition at line 56 of file users.c.

ircmask_list_t ircmask_list = {NULL} [static]

Definition at line 65 of file users.c.

int nusers = 0 [static]

Definition at line 53 of file users.c.

Referenced by real_user_new(), user_count(), user_delete(), and user_load().

const char rcsid[] = "$Id: users.c,v 1.56 2007-05-10 00:25:07 sven Exp $" [static]

Definition at line 21 of file users.c.

hash_table_t* uid_ht = NULL [static]

Definition at line 62 of file users.c.

int uid_wraparound = 0 [static]

Definition at line 50 of file users.c.

Referenced by user_get_uid(), user_load(), and user_save().