ermyth/src/services.C

/*
 * services.C: Routines commonly used by various services.
 * Rights to this code are documented in doc/LICENSE.
 *
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
 */

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

#include "atheme.h"
#include <account/myuser.h>
#include <account/mynick.h>
#include <account/mychan.h>
#include "pmodule.h"

extern dictionary_tree_t *services;
int authservice_loaded = 0;
int use_myuser_access = 0;
int use_svsignore = 0;

#define MAX_BUF 256

/* ban wrapper for cmode, returns number of bans added (0 or 1) */
int
ban (user_t *sender, channel_t *c, user_t *user)
{
  char mask[MAX_BUF];
  char modemask[MAX_BUF];
  chanban_t *cb;

  if (!c)
    return 0;

  snprintf (mask, MAX_BUF, "*!*@%s", user->vhost);
  mask[MAX_BUF - 1] = '\0';

  snprintf (modemask, MAX_BUF, "+b %s", mask);
  modemask[MAX_BUF - 1] = '\0';

  cb = chanban_find (c, mask, 'b');

  if (cb != NULL)
    return 0;

  chanban_add (c, mask, 'b');

  mode_sts (sender->nick, c, modemask);
  return 1;
}

/* returns number of modes removed -- jilles */
int
remove_banlike (user_t *source, channel_t *chan, int type, user_t *target)
{
  char change[MAX_BUF];
  int count = 0;
  node_t *n, *tn;
  chanban_t *cb;

  if (type == 0)
    return 0;
  if (source == NULL || chan == NULL || target == NULL)
    return 0;

  for (n = next_matching_ban (chan, target, type, chan->bans.head); n != NULL; n = next_matching_ban (chan, target, type, tn))
    {
      tn = n->next;
      cb = static_cast<chanban_t *> (n->data);

      snprintf (change, sizeof change, "-%c %s", cb->type, cb->mask);
      mode_sts (source->nick, chan, change);
      chanban_delete (cb);
      count++;
    }
  return count;
}

/* returns number of exceptions removed -- jilles */
int
remove_ban_exceptions (user_t *source, channel_t *chan, user_t *target)
{
  return remove_banlike (source, chan, ircd->except_mchar, target);
}

/* join a channel, creating it if necessary */
void
join (char *chan, char *nick)
{
  channel_t *c;
  user_t *u;
  chanuser_t *cu;
  bool isnew = false;
  mychan_t *mc;
  metadata *md;
  time_t ts;

  u = user_find_named (nick);
  if (!u)
    return;
  c = channel_find (chan);
  if (c == NULL)
    {
      mc = mychan_find (chan);
      if (chansvs.changets && mc != NULL)
        {
          /* Use the previous TS if known, registration
           * time otherwise, but never ever create a channel
           * with TS 0 -- jilles */
          ts = mc->registered;
          md = mc->find_metadata ("private:channelts");
          if (md != NULL)
            ts = atol (md->value);
          if (ts == 0)
            ts = NOW;
        }
      else
        ts = NOW;
      c = channel_add (chan, ts, me.me);
      c->modes |= CMODE_NOEXT | CMODE_TOPIC;
      if (mc != NULL)
        check_modes (mc, false);
      isnew = true;
    }
  else if ((cu = chanuser_find (c, u)))
    {
      slog (LG_DEBUG, "join(): i'm already in `%s'", c->name);
      return;
    }
  join_sts (c, u, isnew, channel_modes (c, true));
  cu = chanuser_add (c, CLIENT_NAME (u));
  cu->modes |= CMODE_OP;
  if (isnew)
    {
      hook_call_event ("channel_add", c);
      if (config_options.chan != NULL && !irccasecmp (config_options.chan, c->name))
        joinall (config_options.chan);
    }
}

/* part a channel */
void
part (char *chan, char *nick)
{
  channel_t *c = channel_find (chan);
  user_t *u = user_find_named (nick);

  if (!u || !c)
    return;
  if (!chanuser_find (c, u))
    return;
  if (me.connected)
    part_sts (c, u);
  chanuser_delete (c, u);
}

void
services_init (void)
{
  service_t *svs;
  dictionary_iteration_state_t state;

  DICTIONARY_FOREACH (svs, service_t, &state, services)
  {
    if (ircd->uses_uid && svs->me->uid[0] == '\0')
      user_changeuid (svs->me, svs->uid);
    else if (!ircd->uses_uid && svs->me->uid[0] != '\0')
      user_changeuid (svs->me, NULL);
    introduce_nick (svs->me);
  }
}

void
joinall (char *name)
{
  service_t *svs;
  dictionary_iteration_state_t state;

  if (name == NULL)
    return;

  DICTIONARY_FOREACH (svs, service_t, &state, services)
  {
    join (name, svs->name);
  }
}

void
partall (char *name)
{
  dictionary_iteration_state_t state;
  service_t *svs;
  mychan_t *mc;

  if (name == NULL)
    return;
  mc = mychan_find (name);
  DICTIONARY_FOREACH (svs, service_t, &state, services)
  {
    if (svs == chansvs.me && mc != NULL && config_options.join_chans)
      continue;
    /* Do not cache this channel_find(), the
     * channel may disappear under our feet
     * -- jilles */
    if (chanuser_find (channel_find (name), svs->me))
      part (name, svs->name);
  }
}

/* reintroduce a service e.g. after it's been killed -- jilles */
void
reintroduce_user (user_t *u)
{
  node_t *n;
  channel_t *c;
  service_t *svs;

  svs = find_service (u->nick);
  if (svs == NULL)
    {
      slog (LG_DEBUG, "tried to reintroduce_user non-service %s", u->nick);
      return;
    }
  introduce_nick (u);
  LIST_FOREACH (n, u->channels.head)
  {
    c = ((chanuser_t *) n->data)->chan;
    if (LIST_LENGTH (&c->members) > 1 || c->modes & ircd->perm_mode)
      join_sts (c, u, 0, channel_modes (c, true));
    else
      {
        /* channel will have been destroyed... */
        /* XXX resend the bans instead of destroying them? */
        chanban_clear (c);
        join_sts (c, u, 1, channel_modes (c, true));
        if (c->topic != NULL)
          topic_sts (c, c->topic_setter, c->topicts, 0, c->topic);
      }
  }
}

void
verbose (mychan_t *mychan, char *fmt, ...)
{
  va_list ap;
  char buf[BUFSIZE];

  if (mychan->chan == NULL)
    return;

  va_start (ap, fmt);
  vsnprintf (buf, BUFSIZE, fmt, ap);
  va_end (ap);

  if ((MC_VERBOSE | MC_FORCEVERBOSE) & mychan->flags)
    notice (chansvs.nick, mychan->name, "%s", buf);
  else if (MC_VERBOSE_OPS & mychan->flags)
    wallchops (chansvs.me->me, mychan->chan, buf);
}

void
snoop (char *fmt, ...)
{
  va_list ap;
  char buf[BUFSIZE];

  if (!config_options.chan)
    return;

  if (me.bursting)
    return;

  if (!channel_find (config_options.chan))
    return;

  va_start (ap, fmt);
  vsnprintf (buf, BUFSIZE, fmt, ap);
  va_end (ap);

  msg (opersvs.nick, config_options.chan, "%s", buf);
}

/* protocol wrapper for nickchange/nick burst */
void
handle_nickchange (user_t *u)
{
  mynick_t *mn;
  hook_nick_enforce_t hdata;

  if (u == NULL)
    return;

  if (runflags & RF_LIVE && log_debug_enabled ())
    notice (globsvs.nick, u->nick, "Services are presently running in debug mode, attached to a console. You should take extra caution when utilizing your services passwords.");

  /* Only do the following checks if nicks are considered owned -- jilles */
  if (nicksvs.me == NULL || nicksvs.no_nick_ownership)
    return;

  /* They're logged in, don't send them spam -- jilles */
  if (u->myuser)
    u->flags |= UF_SEENINFO;

  /* Also don't send it if they came back from a split -- jilles */
  if (!(u->server->flags & SF_EOB))
    u->flags |= UF_SEENINFO;

  if (!(mn = mynick_find (u->nick)))
    {
      if (!nicksvs.spam)
        return;

      if (!(u->flags & UF_SEENINFO))
        {
          notice (nicksvs.nick, u->nick, "Welcome to %s, %s! Here on %s, we provide services to enable the " "registration of nicknames and channels! For details, type \2/%s%s help\2 and \2/%s%s help\2.", me.netname, u->nick, me.netname, (ircd->uses_rcommand == false) ? "msg " : "", nicksvs.disp, (ircd->uses_rcommand == false) ? "msg " : "", chansvs.disp);

          u->flags |= UF_SEENINFO;
        }

      return;
    }

  if (u->myuser == mn->owner)
    {
      mn->lastseen = NOW;
      return;
    }

  /* OpenServices: is user on access list? -nenolod */
  if (myuser_access_verify (u, mn->owner))
    {
      mn->lastseen = NOW;
      return;
    }

  notice (nicksvs.nick, u->nick, _("This nickname is registered. Please choose a different nickname, or identify via \2/%s%s identify <password>\2."), (ircd->uses_rcommand == false) ? "msg " : "", nicksvs.disp);
  hdata.u = u;
  hdata.mn = mn;
  hook_call_event ("nick_enforce", &hdata);
}

/* User u is bursted as being logged in to login (if not NULL) or as
 * being identified to their current nick (if login is NULL)
 * Update the administration or log them out on ircd
 * How to use this in protocol modules:
 * 1. if login info is bursted in a command that always occurs, call
 *    this if the user is logged in, before handle_nickchange()
 * 2. if it is bursted in a command that doesn't always occur, use
 *    netwide EOB as in the ratbox module; call this if the user is logged
 *    in; for all users, postpone handle_nickchange() until the user's
 *    server confirms EOB
 * -- jilles
 */
void
handle_burstlogin (user_t *u, char *login)
{
  mynick_t *mn;
  myuser_t *mu;

  if (login != NULL)
    /* don't allow alias nicks here -- jilles */
    mu = myuser_find (login);
  else
    {
      mn = mynick_find (u->nick);
      mu = mn != NULL ? mn->owner : NULL;
      login = mu != NULL ? mu->name : u->nick;
    }
  if (mu == NULL)
    {
      /* account dropped during split...
       * if we have an authentication service, log them out */
      slog (LG_DEBUG, "handle_burstlogin(): got nonexistent login %s for user %s", login, u->nick);
      if (authservice_loaded)
        {
          notice (nicksvs.nick ? nicksvs.nick : me.name, u->nick, _("Account %s dropped, forcing logout"), login);
          ircd_on_logout (u->nick, login, NULL);
        }
      return;
    }
  if (u->myuser != NULL)        /* already logged in, hmm */
    return;
  if (mu->flags & MU_NOBURSTLOGIN && authservice_loaded)
    {
      /* no splits for this account, this bursted login cannot
       * be legit...
       * if we have an authentication service, log them out */
      slog (LG_INFO, "handle_burstlogin(): got illegit login %s for user %s", login, u->nick);
      notice (nicksvs.nick ? nicksvs.nick : me.name, u->nick, _("Login to account %s seems invalid, forcing logout"), login);
      ircd_on_logout (u->nick, login, NULL);
      return;
    }
  u->myuser = mu;
  mu->logins.insert (u);
  slog (LG_DEBUG, "handle_burstlogin(): automatically identified %s as %s", u->nick, login);
}

/* this could be done with more finesse, but hey! */
void
notice (char *from, char *to, char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];
  user_t *u;
  channel_t *c;

  va_start (args, fmt);
  vsnprintf (buf, BUFSIZE, fmt, args);
  va_end (args);

  if (config_options.use_privmsg)
    msg (from, to, "%s", buf);
  else
    {
      if (*to == '#')
        {
          c = channel_find (to);
          if (c != NULL)
            notice_channel_sts (user_find_named (from), c, buf);
        }
      else
        {
          u = user_find_named (to);
          if (u != NULL)
            notice_user_sts (user_find_named (from), u, buf);
        }
    }
}

void
command_fail (sourceinfo_t *si, faultcode_t code, const char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];

  va_start (args, fmt);
  vsnprintf (buf, sizeof buf, fmt, args);
  va_end (args);

  if (si->su == NULL)
    {
      if (si->v != NULL && si->v->cmd_fail)
        si->v->cmd_fail (si, code, buf);
      return;
    }

  if (config_options.use_privmsg)
    msg (si->service->name, si->su->nick, "%s", buf);
  else
    notice_user_sts (si->service->me, si->su, buf);
}

void
command_success_nodata (sourceinfo_t *si, const char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];

  va_start (args, fmt);
  vsnprintf (buf, BUFSIZE, fmt, args);
  va_end (args);

  if (si->su == NULL)
    {
      if (si->v != NULL && si->v->cmd_fail)
        si->v->cmd_success_nodata (si, buf);
      return;
    }

  if (config_options.use_privmsg)
    msg (si->service->name, si->su->nick, "%s", buf);
  else
    notice_user_sts (si->service->me, si->su, buf);
}

void
command_success_string (sourceinfo_t *si, const char *result, const char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];

  va_start (args, fmt);
  vsnprintf (buf, BUFSIZE, fmt, args);
  va_end (args);

  if (si->su == NULL)
    {
      if (si->v != NULL && si->v->cmd_fail)
        si->v->cmd_success_string (si, result, buf);
      return;
    }

  if (config_options.use_privmsg)
    msg (si->service->name, si->su->nick, "%s", buf);
  else
    notice_user_sts (si->service->me, si->su, buf);
}

static void
command_table_cb (const char *line, void *data)
{
  command_success_nodata (static_cast<sourceinfo_t *> (data), "%s", line);
}

void
command_success_table (sourceinfo_t *si, table_t * table)
{
  table_render (table, command_table_cb, si);
}

const char *
get_source_name (sourceinfo_t *si)
{
  static char result[NICKLEN + NICKLEN + 10];

  if (si->su != NULL)
    {
      if (si->smu && !irccasecmp (si->su->nick, si->smu->name))
        snprintf (result, sizeof result, "%s", si->su->nick);
      else
        snprintf (result, sizeof result, "%s(%s)", si->su->nick, si->smu ? si->smu->name : "");
    }
  else if (si->s != NULL)
    snprintf (result, sizeof result, "%s", si->s->name);
  else
    {
      snprintf (result, sizeof result, "<%s>%s", si->v->description, si->smu ? si->smu->name : "");
    }
  return result;
}

const char *
get_source_mask (sourceinfo_t *si)
{
  static char result[NICKLEN + USERLEN + HOSTLEN + 10];

  if (si->su != NULL)
    {
      snprintf (result, sizeof result, "%s!%s@%s", si->su->nick, si->su->user, si->su->vhost);
    }
  else if (si->s != NULL)
    snprintf (result, sizeof result, "%s", si->s->name);
  else
    {
      snprintf (result, sizeof result, "<%s>%s", si->v->description, si->smu ? si->smu->name : "");
    }
  return result;
}

const char *
get_oper_name (sourceinfo_t *si)
{
  static char result[NICKLEN + USERLEN + HOSTLEN + NICKLEN + 10];

  if (si->su != NULL)
    {
      if (si->smu == NULL)
        snprintf (result, sizeof result, "%s!%s@%s{%s}", si->su->nick, si->su->user, si->su->vhost, si->su->server->name);
      else if (!irccasecmp (si->su->nick, si->smu->name))
        snprintf (result, sizeof result, "%s", si->su->nick);
      else
        snprintf (result, sizeof result, "%s(%s)", si->su->nick, si->smu ? si->smu->name : "");
    }
  else if (si->s != NULL)
    snprintf (result, sizeof result, "%s", si->s->name);
  else
    {
      snprintf (result, sizeof result, "<%s>%s", si->v->description, si->smu ? si->smu->name : "");
    }
  return result;
}

void
wallops (char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];

  if (config_options.silent)
    return;

  va_start (args, fmt);
  vsnprintf (buf, BUFSIZE, fmt, args);
  va_end (args);

  if (me.me != NULL && me.connected)
    wallops_sts (buf);
  else
    slog (LG_ERROR, "wallops(): unable to send: %s", buf);
}

void
verbose_wallops (char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];

  if (config_options.silent || !config_options.verbose_wallops)
    return;

  va_start (args, fmt);
  vsnprintf (buf, BUFSIZE, fmt, args);
  va_end (args);

  if (me.me != NULL && me.connected)
    wallops_sts (buf);
  else
    slog (LG_ERROR, "verbose_wallops(): unable to send: %s", buf);
}

/* 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.1
Committed:	Thu Jul 19 08:24:59 2007 UTC (16 years, 10 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Log Message:	initial import. the most important changes since Atheme are: - fixed many memory leaks - fixed many bugs - converted to C++ and use more STL containers - added a (not very enhanced yet) perl module - greatly improved XML-RPC speed - added a JSON-RPC module with code from json-cpp - added a valgrind memcheck module to operserv - added a more object oriented base64 implementation - added a specialised unit test framework - improved stability - use gettimeofday() if available - reworked adding/removing commands - MemoServ IGNORE DEL can now remove indices
#	Content
1	/*
2	* services.C: Routines commonly used by various services.
3	* Rights to this code are documented in doc/LICENSE.
4	*
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/myuser.h>
12	#include <account/mynick.h>
13	#include <account/mychan.h>
14	#include "pmodule.h"
15
16	extern dictionary_tree_t *services;
17	int authservice_loaded = 0;
18	int use_myuser_access = 0;
19	int use_svsignore = 0;
20
21	#define MAX_BUF 256
22
23	/* ban wrapper for cmode, returns number of bans added (0 or 1) */
24	int
25	ban (user_t sender, channel_t c, user_t *user)
26	{
27	char mask[MAX_BUF];
28	char modemask[MAX_BUF];
29	chanban_t *cb;
30
31	if (!c)
32	return 0;
33
34	snprintf (mask, MAX_BUF, "!@%s", user->vhost);
35	mask[MAX_BUF - 1] = '\0';
36
37	snprintf (modemask, MAX_BUF, "+b %s", mask);
38	modemask[MAX_BUF - 1] = '\0';
39
40	cb = chanban_find (c, mask, 'b');
41
42	if (cb != NULL)
43	return 0;
44
45	chanban_add (c, mask, 'b');
46
47	mode_sts (sender->nick, c, modemask);
48	return 1;
49	}
50
51	/* returns number of modes removed -- jilles */
52	int
53	remove_banlike (user_t source, channel_t chan, int type, user_t *target)
54	{
55	char change[MAX_BUF];
56	int count = 0;
57	node_t n, tn;
58	chanban_t *cb;
59
60	if (type == 0)
61	return 0;
62	if (source == NULL \|\| chan == NULL \|\| target == NULL)
63	return 0;
64
65	for (n = next_matching_ban (chan, target, type, chan->bans.head); n != NULL; n = next_matching_ban (chan, target, type, tn))
66	{
67	tn = n->next;
68	cb = static_cast<chanban_t *> (n->data);
69
70	snprintf (change, sizeof change, "-%c %s", cb->type, cb->mask);
71	mode_sts (source->nick, chan, change);
72	chanban_delete (cb);
73	count++;
74	}
75	return count;
76	}
77
78	/* returns number of exceptions removed -- jilles */
79	int
80	remove_ban_exceptions (user_t source, channel_t chan, user_t *target)
81	{
82	return remove_banlike (source, chan, ircd->except_mchar, target);
83	}
84
85	/* join a channel, creating it if necessary */
86	void
87	join (char chan, char nick)
88	{
89	channel_t *c;
90	user_t *u;
91	chanuser_t *cu;
92	bool isnew = false;
93	mychan_t *mc;
94	metadata *md;
95	time_t ts;
96
97	u = user_find_named (nick);
98	if (!u)
99	return;
100	c = channel_find (chan);
101	if (c == NULL)
102	{
103	mc = mychan_find (chan);
104	if (chansvs.changets && mc != NULL)
105	{
106	/* Use the previous TS if known, registration
107	* time otherwise, but never ever create a channel
108	* with TS 0 -- jilles */
109	ts = mc->registered;
110	md = mc->find_metadata ("private:channelts");
111	if (md != NULL)
112	ts = atol (md->value);
113	if (ts == 0)
114	ts = NOW;
115	}
116	else
117	ts = NOW;
118	c = channel_add (chan, ts, me.me);
119	c->modes \|= CMODE_NOEXT \| CMODE_TOPIC;
120	if (mc != NULL)
121	check_modes (mc, false);
122	isnew = true;
123	}
124	else if ((cu = chanuser_find (c, u)))
125	{
126	slog (LG_DEBUG, "join(): i'm already in `%s'", c->name);
127	return;
128	}
129	join_sts (c, u, isnew, channel_modes (c, true));
130	cu = chanuser_add (c, CLIENT_NAME (u));
131	cu->modes \|= CMODE_OP;
132	if (isnew)
133	{
134	hook_call_event ("channel_add", c);
135	if (config_options.chan != NULL && !irccasecmp (config_options.chan, c->name))
136	joinall (config_options.chan);
137	}
138	}
139
140	/* part a channel */
141	void
142	part (char chan, char nick)
143	{
144	channel_t *c = channel_find (chan);
145	user_t *u = user_find_named (nick);
146
147	if (!u \|\| !c)
148	return;
149	if (!chanuser_find (c, u))
150	return;
151	if (me.connected)
152	part_sts (c, u);
153	chanuser_delete (c, u);
154	}
155
156	void
157	services_init (void)
158	{
159	service_t *svs;
160	dictionary_iteration_state_t state;
161
162	DICTIONARY_FOREACH (svs, service_t, &state, services)
163	{
164	if (ircd->uses_uid && svs->me->uid[0] == '\0')
165	user_changeuid (svs->me, svs->uid);
166	else if (!ircd->uses_uid && svs->me->uid[0] != '\0')
167	user_changeuid (svs->me, NULL);
168	introduce_nick (svs->me);
169	}
170	}
171
172	void
173	joinall (char *name)
174	{
175	service_t *svs;
176	dictionary_iteration_state_t state;
177
178	if (name == NULL)
179	return;
180
181	DICTIONARY_FOREACH (svs, service_t, &state, services)
182	{
183	join (name, svs->name);
184	}
185	}
186
187	void
188	partall (char *name)
189	{
190	dictionary_iteration_state_t state;
191	service_t *svs;
192	mychan_t *mc;
193
194	if (name == NULL)
195	return;
196	mc = mychan_find (name);
197	DICTIONARY_FOREACH (svs, service_t, &state, services)
198	{
199	if (svs == chansvs.me && mc != NULL && config_options.join_chans)
200	continue;
201	/* Do not cache this channel_find(), the
202	* channel may disappear under our feet
203	* -- jilles */
204	if (chanuser_find (channel_find (name), svs->me))
205	part (name, svs->name);
206	}
207	}
208
209	/* reintroduce a service e.g. after it's been killed -- jilles */
210	void
211	reintroduce_user (user_t *u)
212	{
213	node_t *n;
214	channel_t *c;
215	service_t *svs;
216
217	svs = find_service (u->nick);
218	if (svs == NULL)
219	{
220	slog (LG_DEBUG, "tried to reintroduce_user non-service %s", u->nick);
221	return;
222	}
223	introduce_nick (u);
224	LIST_FOREACH (n, u->channels.head)
225	{
226	c = ((chanuser_t *) n->data)->chan;
227	if (LIST_LENGTH (&c->members) > 1 \|\| c->modes & ircd->perm_mode)
228	join_sts (c, u, 0, channel_modes (c, true));
229	else
230	{
231	/* channel will have been destroyed... */
232	/* XXX resend the bans instead of destroying them? */
233	chanban_clear (c);
234	join_sts (c, u, 1, channel_modes (c, true));
235	if (c->topic != NULL)
236	topic_sts (c, c->topic_setter, c->topicts, 0, c->topic);
237	}
238	}
239	}
240
241	void
242	verbose (mychan_t mychan, char fmt, ...)
243	{
244	va_list ap;
245	char buf[BUFSIZE];
246
247	if (mychan->chan == NULL)
248	return;
249
250	va_start (ap, fmt);
251	vsnprintf (buf, BUFSIZE, fmt, ap);
252	va_end (ap);
253
254	if ((MC_VERBOSE \| MC_FORCEVERBOSE) & mychan->flags)
255	notice (chansvs.nick, mychan->name, "%s", buf);
256	else if (MC_VERBOSE_OPS & mychan->flags)
257	wallchops (chansvs.me->me, mychan->chan, buf);
258	}
259
260	void
261	snoop (char *fmt, ...)
262	{
263	va_list ap;
264	char buf[BUFSIZE];
265
266	if (!config_options.chan)
267	return;
268
269	if (me.bursting)
270	return;
271
272	if (!channel_find (config_options.chan))
273	return;
274
275	va_start (ap, fmt);
276	vsnprintf (buf, BUFSIZE, fmt, ap);
277	va_end (ap);
278
279	msg (opersvs.nick, config_options.chan, "%s", buf);
280	}
281
282	/* protocol wrapper for nickchange/nick burst */
283	void
284	handle_nickchange (user_t *u)
285	{
286	mynick_t *mn;
287	hook_nick_enforce_t hdata;
288
289	if (u == NULL)
290	return;
291
292	if (runflags & RF_LIVE && log_debug_enabled ())
293	notice (globsvs.nick, u->nick, "Services are presently running in debug mode, attached to a console. You should take extra caution when utilizing your services passwords.");
294
295	/* Only do the following checks if nicks are considered owned -- jilles */
296	if (nicksvs.me == NULL \|\| nicksvs.no_nick_ownership)
297	return;
298
299	/* They're logged in, don't send them spam -- jilles */
300	if (u->myuser)
301	u->flags \|= UF_SEENINFO;
302
303	/* Also don't send it if they came back from a split -- jilles */
304	if (!(u->server->flags & SF_EOB))
305	u->flags \|= UF_SEENINFO;
306
307	if (!(mn = mynick_find (u->nick)))
308	{
309	if (!nicksvs.spam)
310	return;
311
312	if (!(u->flags & UF_SEENINFO))
313	{
314	notice (nicksvs.nick, u->nick, "Welcome to %s, %s! Here on %s, we provide services to enable the " "registration of nicknames and channels! For details, type \2/%s%s help\2 and \2/%s%s help\2.", me.netname, u->nick, me.netname, (ircd->uses_rcommand == false) ? "msg " : "", nicksvs.disp, (ircd->uses_rcommand == false) ? "msg " : "", chansvs.disp);
315
316	u->flags \|= UF_SEENINFO;
317	}
318
319	return;
320	}
321
322	if (u->myuser == mn->owner)
323	{
324	mn->lastseen = NOW;
325	return;
326	}
327
328	/* OpenServices: is user on access list? -nenolod */
329	if (myuser_access_verify (u, mn->owner))
330	{
331	mn->lastseen = NOW;
332	return;
333	}
334
335	notice (nicksvs.nick, u->nick, _("This nickname is registered. Please choose a different nickname, or identify via \2/%s%s identify <password>\2."), (ircd->uses_rcommand == false) ? "msg " : "", nicksvs.disp);
336	hdata.u = u;
337	hdata.mn = mn;
338	hook_call_event ("nick_enforce", &hdata);
339	}
340
341	/* User u is bursted as being logged in to login (if not NULL) or as
342	* being identified to their current nick (if login is NULL)
343	* Update the administration or log them out on ircd
344	* How to use this in protocol modules:
345	* 1. if login info is bursted in a command that always occurs, call
346	* this if the user is logged in, before handle_nickchange()
347	* 2. if it is bursted in a command that doesn't always occur, use
348	* netwide EOB as in the ratbox module; call this if the user is logged
349	* in; for all users, postpone handle_nickchange() until the user's
350	* server confirms EOB
351	* -- jilles
352	*/
353	void
354	handle_burstlogin (user_t u, char login)
355	{
356	mynick_t *mn;
357	myuser_t *mu;
358
359	if (login != NULL)
360	/* don't allow alias nicks here -- jilles */
361	mu = myuser_find (login);
362	else
363	{
364	mn = mynick_find (u->nick);
365	mu = mn != NULL ? mn->owner : NULL;
366	login = mu != NULL ? mu->name : u->nick;
367	}
368	if (mu == NULL)
369	{
370	/* account dropped during split...
371	* if we have an authentication service, log them out */
372	slog (LG_DEBUG, "handle_burstlogin(): got nonexistent login %s for user %s", login, u->nick);
373	if (authservice_loaded)
374	{
375	notice (nicksvs.nick ? nicksvs.nick : me.name, u->nick, _("Account %s dropped, forcing logout"), login);
376	ircd_on_logout (u->nick, login, NULL);
377	}
378	return;
379	}
380	if (u->myuser != NULL) /* already logged in, hmm */
381	return;
382	if (mu->flags & MU_NOBURSTLOGIN && authservice_loaded)
383	{
384	/* no splits for this account, this bursted login cannot
385	* be legit...
386	* if we have an authentication service, log them out */
387	slog (LG_INFO, "handle_burstlogin(): got illegit login %s for user %s", login, u->nick);
388	notice (nicksvs.nick ? nicksvs.nick : me.name, u->nick, _("Login to account %s seems invalid, forcing logout"), login);
389	ircd_on_logout (u->nick, login, NULL);
390	return;
391	}
392	u->myuser = mu;
393	mu->logins.insert (u);
394	slog (LG_DEBUG, "handle_burstlogin(): automatically identified %s as %s", u->nick, login);
395	}
396
397	/* this could be done with more finesse, but hey! */
398	void
399	notice (char from, char to, char *fmt, ...)
400	{
401	va_list args;
402	char buf[BUFSIZE];
403	user_t *u;
404	channel_t *c;
405
406	va_start (args, fmt);
407	vsnprintf (buf, BUFSIZE, fmt, args);
408	va_end (args);
409
410	if (config_options.use_privmsg)
411	msg (from, to, "%s", buf);
412	else
413	{
414	if (*to == '#')
415	{
416	c = channel_find (to);
417	if (c != NULL)
418	notice_channel_sts (user_find_named (from), c, buf);
419	}
420	else
421	{
422	u = user_find_named (to);
423	if (u != NULL)
424	notice_user_sts (user_find_named (from), u, buf);
425	}
426	}
427	}
428
429	void
430	command_fail (sourceinfo_t si, faultcode_t code, const char fmt, ...)
431	{
432	va_list args;
433	char buf[BUFSIZE];
434
435	va_start (args, fmt);
436	vsnprintf (buf, sizeof buf, fmt, args);
437	va_end (args);
438
439	if (si->su == NULL)
440	{
441	if (si->v != NULL && si->v->cmd_fail)
442	si->v->cmd_fail (si, code, buf);
443	return;
444	}
445
446	if (config_options.use_privmsg)
447	msg (si->service->name, si->su->nick, "%s", buf);
448	else
449	notice_user_sts (si->service->me, si->su, buf);
450	}
451
452	void
453	command_success_nodata (sourceinfo_t si, const char fmt, ...)
454	{
455	va_list args;
456	char buf[BUFSIZE];
457
458	va_start (args, fmt);
459	vsnprintf (buf, BUFSIZE, fmt, args);
460	va_end (args);
461
462	if (si->su == NULL)
463	{
464	if (si->v != NULL && si->v->cmd_fail)
465	si->v->cmd_success_nodata (si, buf);
466	return;
467	}
468
469	if (config_options.use_privmsg)
470	msg (si->service->name, si->su->nick, "%s", buf);
471	else
472	notice_user_sts (si->service->me, si->su, buf);
473	}
474
475	void
476	command_success_string (sourceinfo_t si, const char result, const char *fmt, ...)
477	{
478	va_list args;
479	char buf[BUFSIZE];
480
481	va_start (args, fmt);
482	vsnprintf (buf, BUFSIZE, fmt, args);
483	va_end (args);
484
485	if (si->su == NULL)
486	{
487	if (si->v != NULL && si->v->cmd_fail)
488	si->v->cmd_success_string (si, result, buf);
489	return;
490	}
491
492	if (config_options.use_privmsg)
493	msg (si->service->name, si->su->nick, "%s", buf);
494	else
495	notice_user_sts (si->service->me, si->su, buf);
496	}
497
498	static void
499	command_table_cb (const char line, void data)
500	{
501	command_success_nodata (static_cast<sourceinfo_t *> (data), "%s", line);
502	}
503
504	void
505	command_success_table (sourceinfo_t si, table_t table)
506	{
507	table_render (table, command_table_cb, si);
508	}
509
510	const char *
511	get_source_name (sourceinfo_t *si)
512	{
513	static char result[NICKLEN + NICKLEN + 10];
514
515	if (si->su != NULL)
516	{
517	if (si->smu && !irccasecmp (si->su->nick, si->smu->name))
518	snprintf (result, sizeof result, "%s", si->su->nick);
519	else
520	snprintf (result, sizeof result, "%s(%s)", si->su->nick, si->smu ? si->smu->name : "");
521	}
522	else if (si->s != NULL)
523	snprintf (result, sizeof result, "%s", si->s->name);
524	else
525	{
526	snprintf (result, sizeof result, "<%s>%s", si->v->description, si->smu ? si->smu->name : "");
527	}
528	return result;
529	}
530
531	const char *
532	get_source_mask (sourceinfo_t *si)
533	{
534	static char result[NICKLEN + USERLEN + HOSTLEN + 10];
535
536	if (si->su != NULL)
537	{
538	snprintf (result, sizeof result, "%s!%s@%s", si->su->nick, si->su->user, si->su->vhost);
539	}
540	else if (si->s != NULL)
541	snprintf (result, sizeof result, "%s", si->s->name);
542	else
543	{
544	snprintf (result, sizeof result, "<%s>%s", si->v->description, si->smu ? si->smu->name : "");
545	}
546	return result;
547	}
548
549	const char *
550	get_oper_name (sourceinfo_t *si)
551	{
552	static char result[NICKLEN + USERLEN + HOSTLEN + NICKLEN + 10];
553
554	if (si->su != NULL)
555	{
556	if (si->smu == NULL)
557	snprintf (result, sizeof result, "%s!%s@%s{%s}", si->su->nick, si->su->user, si->su->vhost, si->su->server->name);
558	else if (!irccasecmp (si->su->nick, si->smu->name))
559	snprintf (result, sizeof result, "%s", si->su->nick);
560	else
561	snprintf (result, sizeof result, "%s(%s)", si->su->nick, si->smu ? si->smu->name : "");
562	}
563	else if (si->s != NULL)
564	snprintf (result, sizeof result, "%s", si->s->name);
565	else
566	{
567	snprintf (result, sizeof result, "<%s>%s", si->v->description, si->smu ? si->smu->name : "");
568	}
569	return result;
570	}
571
572	void
573	wallops (char *fmt, ...)
574	{
575	va_list args;
576	char buf[BUFSIZE];
577
578	if (config_options.silent)
579	return;
580
581	va_start (args, fmt);
582	vsnprintf (buf, BUFSIZE, fmt, args);
583	va_end (args);
584
585	if (me.me != NULL && me.connected)
586	wallops_sts (buf);
587	else
588	slog (LG_ERROR, "wallops(): unable to send: %s", buf);
589	}
590
591	void
592	verbose_wallops (char *fmt, ...)
593	{
594	va_list args;
595	char buf[BUFSIZE];
596
597	if (config_options.silent \|\| !config_options.verbose_wallops)
598	return;
599
600	va_start (args, fmt);
601	vsnprintf (buf, BUFSIZE, fmt, args);
602	va_end (args);
603
604	if (me.me != NULL && me.connected)
605	wallops_sts (buf);
606	else
607	slog (LG_ERROR, "verbose_wallops(): unable to send: %s", buf);
608	}
609
610	/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
611	* vim:ts=8
612	* vim:sw=8
613	* vim:noexpandtab
614	*/