ermyth/src/privs.C

/*
 * privs.C: Services operator privileges
 *
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are as documented in COPYING.
 *
 *
 * Portions of this file were derived from sources bearing the following license:
 * Rights to this code are documented in doc/pod/license.pod.
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
 */

static char const rcsid[] = "$Id: privs.C,v 1.5 2007-08-28 22:18:31 pippijn Exp $";

#include "atheme.h"
#include <account/myuser.h>
#include "privs.h"

list_t operclasslist;
list_t soperlist;

void
init_privs (void)
{
#if 0
  operclass_heap = BlockHeapCreate (sizeof (operclass_t), 2);
  soper_heap = BlockHeapCreate (sizeof (soper_t), 2);
#endif
}

/*************************
 * O P E R C L A S S E S *
 *************************/
operclass_t *
operclass_add (char *name, char const *privs)
{
  operclass_t *operclass;
  node_t *n = node_create ();

  operclass = operclass_find (name);
  if (operclass != NULL)
    {
      slog (LG_DEBUG, "operclass_add(): duplicate class %s", name);
      return NULL;
    }
  slog (LG_DEBUG, "operclass_add(): %s [%s]", name, privs);
  operclass = new operclass_t;
  node_add (operclass, n, &operclasslist);
  operclass->name = sstrdup (name);
  operclass->privs = sstrdup (privs);
  cnt.operclass++;
  LIST_FOREACH (n, soperlist.head)
  {
    soper_t *soper = static_cast<soper_t *> (n->data);
    if (soper->operclass == NULL && !strcasecmp (name, soper->classname))
      soper->operclass = operclass;
  }
  return operclass;
}

void
operclass_delete (operclass_t *operclass)
{
  node_t *n;

  if (operclass == NULL)
    return;
  slog (LG_DEBUG, "operclass_delete(): %s", operclass->name);
  n = node_find (operclass, &operclasslist);
  node_del (n, &operclasslist);
  node_free (n);
  LIST_FOREACH (n, soperlist.head)
  {
    soper_t *soper = static_cast<soper_t *> (n->data);
    if (soper->operclass == operclass)
      soper->operclass = NULL;
  }
  sfree (operclass->name);
  sfree (operclass->privs);
  delete operclass;
  cnt.operclass--;
}

operclass_t *
operclass_find (char const * const name)
{
  operclass_t *operclass;
  node_t *n;

  LIST_FOREACH (n, operclasslist.head)
  {
    operclass = (operclass_t *) n->data;

    if (!strcasecmp (operclass->name, name))
      return operclass;
  }

  return NULL;
}

/***************
 * S O P E R S *
 ***************/

soper_t *
soper_add (char *name, char *classname, int flags)
{
  soper_t *soper;
  myuser_t *mu = myuser_t::find (name);
  node_t *n;
  operclass_t *operclass = operclass_find (classname);

  soper = mu ? soper_find (mu) : soper_find_named (name);
  if (soper != NULL)
    {
      if (flags & SOPER_CONF && !(soper->flags & SOPER_CONF))
        {
          slog (LG_INFO, "soper_add(): conf soper %s (%s) is replacing DB soper with class %s", name, classname, soper->classname);
          soper_delete (soper);
        }
      else if (!(flags & SOPER_CONF) && soper->flags & SOPER_CONF)
        {
          slog (LG_INFO, "soper_add(): ignoring DB soper %s (%s) because of conf soper with class %s", name, classname, soper->classname);
          return NULL;
        }
      else
        {
          slog (LG_INFO, "soper_add(): duplicate soper %s", name);
          return NULL;
        }
    }
  slog (LG_DEBUG, "soper_add(): %s -> %s", (mu) ? mu->name : name, operclass ? operclass->name : "<null>");

  soper = new soper_t;
  n = node_create ();

  node_add (soper, n, &soperlist);

  if (mu)
    {
      soper->myuser = mu;
      mu->soper = soper;
      soper->name = NULL;
    }
  else
    {
      soper->name = sstrdup (name);
      soper->myuser = NULL;
    }
  soper->operclass = operclass;
  soper->classname = sstrdup (classname);
  soper->flags = flags;

  cnt.soper++;

  return soper;
}

void
soper_delete (soper_t *soper)
{
  node_t *n;

  if (!soper)
    {
      slog (LG_DEBUG, "soper_delete(): called for null soper");

      return;
    }

  slog (LG_DEBUG, "soper_delete(): %s", (soper->myuser) ? soper->myuser->name : soper->name);

  n = node_find (soper, &soperlist);
  node_del (n, &soperlist);
  node_free (n);

  if (soper->myuser)
    soper->myuser->soper = NULL;

  if (soper->name)
    sfree (soper->name);

  sfree (soper->classname);

  delete soper;

  cnt.soper--;
}

soper_t *
soper_find (myuser_t *myuser)
{
  soper_t *soper;
  node_t *n;

  LIST_FOREACH (n, soperlist.head)
  {
    soper = (soper_t *) n->data;

    if (soper->myuser && soper->myuser == myuser)
      return soper;
  }

  return NULL;
}

soper_t *
soper_find_named (char *name)
{
  soper_t *soper;
  node_t *n;

  LIST_FOREACH (n, soperlist.head)
  {
    soper = (soper_t *) n->data;

    if (soper->name && !irccasecmp (soper->name, name))
      return soper;
  }

  return NULL;
}

bool
is_soper (myuser_t *myuser)
{
  if (!myuser)
    return false;

  if (myuser->soper)
    return true;

  return false;
}

bool
is_conf_soper (myuser_t *myuser)
{
  if (!myuser)
    return false;

  if (myuser->soper && myuser->soper->flags & SOPER_CONF)
    return true;

  return false;
}

/* name1 name2 name3... */
static bool
string_in_list (char const * const str, char const * const name)
{
  char *p;
  char const *s = str;
  int l;

  if (s == NULL)
    return false;
  l = strlen (name);
  while (*s != '\0')
    {
      p = strchr (s, ' ');
      if (p != NULL ? p - s == l && !strncasecmp (s, name, p - s) : !strcasecmp (s, name))
        return true;
      if (p == NULL)
        return false;
      s = p;
      while (*s == ' ')
        s++;
    }
  return false;
}

bool
has_any_privs (sourceinfo_t *si)
{
  if (si->su != NULL && is_ircop (si->su))
    return true;
  if (si->smu && is_soper (si->smu))
    return true;
  return false;
}

bool
has_any_privs_user (user_t *u)
{
  if (u == NULL)
    return false;
  if (is_ircop (u))
    return true;
  if (u->myuser && is_soper (u->myuser))
    return true;
  return false;
}

bool
has_priv (sourceinfo_t *si, char const * const priv)
{
  return si->su != NULL ? has_priv_user (si->su, priv) : has_priv_myuser (si->smu, priv);
}

bool
has_priv_user (user_t *u, char const * const priv)
{
  operclass_t *operclass;

  if (priv == NULL)
    return true;
  if (u == NULL)
    return false;
  if (is_ircop (u))
    {
      operclass = operclass_find ("ircop");
      if (operclass != NULL && string_in_list (operclass->privs, priv))
        return true;
    }
  if (u->myuser && is_soper (u->myuser))
    {
      operclass = u->myuser->soper->operclass;
      if (operclass == NULL)
        return false;
      if (operclass->flags & OPERCLASS_NEEDOPER && !is_ircop (u))
        return false;
      if (string_in_list (operclass->privs, priv))
        return true;
    }
  return false;
}

bool
has_priv_myuser (myuser_t *mu, char const * const priv)
{
  operclass_t *operclass;

  if (priv == NULL)
    return true;
  if (mu == NULL)
    return false;
  if (!is_soper (mu))
    return false;
  operclass = mu->soper->operclass;
  if (operclass == NULL)
    return false;
  if (string_in_list (operclass->privs, priv))
    return true;
  return false;
}

bool
has_priv_operclass (operclass_t *operclass, char const * const priv)
{
  if (operclass == NULL)
    return false;
  if (string_in_list (operclass->privs, priv))
    return true;
  return false;
}

bool
has_all_operclass (sourceinfo_t *si, operclass_t *operclass)
{
  char *privs2;
  char *priv;

  privs2 = sstrdup (operclass->privs);
  priv = strtok (privs2, " ");
  while (priv != NULL)
    {
      if (!has_priv (si, priv))
        {
          sfree (privs2);
          return false;
        }
      priv = strtok (NULL, " ");
    }
  sfree (privs2);
  return true;
}
Revision:	1.6
Committed:	Sun Sep 16 18:54:45 2007 UTC (16 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+7 -2 lines
Log Message:	#defines to enum
#	User	Rev	Content
1	pippijn	1.1	/*
2			* privs.C: Services operator privileges
3	pippijn	1.6	*
4			* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
5			* Rights to this code are as documented in COPYING.
6			*
7			*
8			* Portions of this file were derived from sources bearing the following license:
9	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
10	pippijn	1.4	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
11	pippijn	1.1	*/
12
13	pippijn	1.6	static char const rcsid[] = "$Id: privs.C,v 1.5 2007-08-28 22:18:31 pippijn Exp $";
14	pippijn	1.1
15			#include "atheme.h"
16			#include <account/myuser.h>
17			#include "privs.h"
18
19			list_t operclasslist;
20			list_t soperlist;
21
22			void
23			init_privs (void)
24			{
25	pippijn	1.4	#if 0
26	pippijn	1.1	operclass_heap = BlockHeapCreate (sizeof (operclass_t), 2);
27			soper_heap = BlockHeapCreate (sizeof (soper_t), 2);
28	pippijn	1.4	#endif
29	pippijn	1.1	}
30
31			/*************************
32			* O P E R C L A S S E S *
33			*************************/
34			operclass_t *
35			operclass_add (char name, char const privs)
36			{
37			operclass_t *operclass;
38			node_t *n = node_create ();
39
40			operclass = operclass_find (name);
41			if (operclass != NULL)
42			{
43			slog (LG_DEBUG, "operclass_add(): duplicate class %s", name);
44			return NULL;
45			}
46			slog (LG_DEBUG, "operclass_add(): %s [%s]", name, privs);
47	pippijn	1.4	operclass = new operclass_t;
48	pippijn	1.1	node_add (operclass, n, &operclasslist);
49			operclass->name = sstrdup (name);
50			operclass->privs = sstrdup (privs);
51			cnt.operclass++;
52			LIST_FOREACH (n, soperlist.head)
53			{
54			soper_t soper = static_cast<soper_t > (n->data);
55			if (soper->operclass == NULL && !strcasecmp (name, soper->classname))
56			soper->operclass = operclass;
57			}
58			return operclass;
59			}
60
61			void
62			operclass_delete (operclass_t *operclass)
63			{
64			node_t *n;
65
66			if (operclass == NULL)
67			return;
68			slog (LG_DEBUG, "operclass_delete(): %s", operclass->name);
69			n = node_find (operclass, &operclasslist);
70			node_del (n, &operclasslist);
71			node_free (n);
72			LIST_FOREACH (n, soperlist.head)
73			{
74			soper_t soper = static_cast<soper_t > (n->data);
75			if (soper->operclass == operclass)
76			soper->operclass = NULL;
77			}
78	pippijn	1.4	sfree (operclass->name);
79			sfree (operclass->privs);
80			delete operclass;
81	pippijn	1.1	cnt.operclass--;
82			}
83
84			operclass_t *
85	pippijn	1.4	operclass_find (char const * const name)
86	pippijn	1.1	{
87			operclass_t *operclass;
88			node_t *n;
89
90			LIST_FOREACH (n, operclasslist.head)
91			{
92			operclass = (operclass_t *) n->data;
93
94			if (!strcasecmp (operclass->name, name))
95			return operclass;
96			}
97
98			return NULL;
99			}
100
101			/***************
102			* S O P E R S *
103			***************/
104
105			soper_t *
106			soper_add (char name, char classname, int flags)
107			{
108			soper_t *soper;
109	pippijn	1.5	myuser_t *mu = myuser_t::find (name);
110	pippijn	1.1	node_t *n;
111			operclass_t *operclass = operclass_find (classname);
112
113			soper = mu ? soper_find (mu) : soper_find_named (name);
114			if (soper != NULL)
115			{
116			if (flags & SOPER_CONF && !(soper->flags & SOPER_CONF))
117			{
118			slog (LG_INFO, "soper_add(): conf soper %s (%s) is replacing DB soper with class %s", name, classname, soper->classname);
119			soper_delete (soper);
120			}
121			else if (!(flags & SOPER_CONF) && soper->flags & SOPER_CONF)
122			{
123			slog (LG_INFO, "soper_add(): ignoring DB soper %s (%s) because of conf soper with class %s", name, classname, soper->classname);
124			return NULL;
125			}
126			else
127			{
128			slog (LG_INFO, "soper_add(): duplicate soper %s", name);
129			return NULL;
130			}
131			}
132			slog (LG_DEBUG, "soper_add(): %s -> %s", (mu) ? mu->name : name, operclass ? operclass->name : "<null>");
133
134	pippijn	1.4	soper = new soper_t;
135	pippijn	1.1	n = node_create ();
136
137			node_add (soper, n, &soperlist);
138
139			if (mu)
140			{
141			soper->myuser = mu;
142			mu->soper = soper;
143			soper->name = NULL;
144			}
145			else
146			{
147			soper->name = sstrdup (name);
148			soper->myuser = NULL;
149			}
150			soper->operclass = operclass;
151			soper->classname = sstrdup (classname);
152			soper->flags = flags;
153
154			cnt.soper++;
155
156			return soper;
157			}
158
159			void
160			soper_delete (soper_t *soper)
161			{
162			node_t *n;
163
164			if (!soper)
165			{
166			slog (LG_DEBUG, "soper_delete(): called for null soper");
167
168			return;
169			}
170
171			slog (LG_DEBUG, "soper_delete(): %s", (soper->myuser) ? soper->myuser->name : soper->name);
172
173			n = node_find (soper, &soperlist);
174			node_del (n, &soperlist);
175			node_free (n);
176
177			if (soper->myuser)
178			soper->myuser->soper = NULL;
179
180			if (soper->name)
181	pippijn	1.4	sfree (soper->name);
182	pippijn	1.1
183	pippijn	1.4	sfree (soper->classname);
184	pippijn	1.1
185	pippijn	1.4	delete soper;
186	pippijn	1.1
187			cnt.soper--;
188			}
189
190			soper_t *
191			soper_find (myuser_t *myuser)
192			{
193			soper_t *soper;
194			node_t *n;
195
196			LIST_FOREACH (n, soperlist.head)
197			{
198			soper = (soper_t *) n->data;
199
200			if (soper->myuser && soper->myuser == myuser)
201			return soper;
202			}
203
204			return NULL;
205			}
206
207			soper_t *
208			soper_find_named (char *name)
209			{
210			soper_t *soper;
211			node_t *n;
212
213			LIST_FOREACH (n, soperlist.head)
214			{
215			soper = (soper_t *) n->data;
216
217			if (soper->name && !irccasecmp (soper->name, name))
218			return soper;
219			}
220
221			return NULL;
222			}
223
224			bool
225			is_soper (myuser_t *myuser)
226			{
227			if (!myuser)
228			return false;
229
230			if (myuser->soper)
231			return true;
232
233			return false;
234			}
235
236			bool
237			is_conf_soper (myuser_t *myuser)
238			{
239			if (!myuser)
240			return false;
241
242			if (myuser->soper && myuser->soper->flags & SOPER_CONF)
243			return true;
244
245			return false;
246			}
247
248			/* name1 name2 name3... */
249			static bool
250	pippijn	1.4	string_in_list (char const * const str, char const * const name)
251	pippijn	1.1	{
252			char *p;
253	pippijn	1.4	char const *s = str;
254	pippijn	1.1	int l;
255
256	pippijn	1.4	if (s == NULL)
257	pippijn	1.1	return false;
258			l = strlen (name);
259	pippijn	1.4	while (*s != '\0')
260	pippijn	1.1	{
261	pippijn	1.4	p = strchr (s, ' ');
262			if (p != NULL ? p - s == l && !strncasecmp (s, name, p - s) : !strcasecmp (s, name))
263	pippijn	1.1	return true;
264			if (p == NULL)
265			return false;
266	pippijn	1.4	s = p;
267			while (*s == ' ')
268			s++;
269	pippijn	1.1	}
270			return false;
271			}
272
273			bool
274			has_any_privs (sourceinfo_t *si)
275			{
276			if (si->su != NULL && is_ircop (si->su))
277			return true;
278			if (si->smu && is_soper (si->smu))
279			return true;
280			return false;
281			}
282
283			bool
284			has_any_privs_user (user_t *u)
285			{
286			if (u == NULL)
287			return false;
288			if (is_ircop (u))
289			return true;
290			if (u->myuser && is_soper (u->myuser))
291			return true;
292			return false;
293			}
294
295			bool
296	pippijn	1.4	has_priv (sourceinfo_t si, char const const priv)
297	pippijn	1.1	{
298			return si->su != NULL ? has_priv_user (si->su, priv) : has_priv_myuser (si->smu, priv);
299			}
300
301			bool
302	pippijn	1.4	has_priv_user (user_t u, char const const priv)
303	pippijn	1.1	{
304			operclass_t *operclass;
305
306			if (priv == NULL)
307			return true;
308			if (u == NULL)
309			return false;
310			if (is_ircop (u))
311			{
312			operclass = operclass_find ("ircop");
313			if (operclass != NULL && string_in_list (operclass->privs, priv))
314			return true;
315			}
316			if (u->myuser && is_soper (u->myuser))
317			{
318			operclass = u->myuser->soper->operclass;
319			if (operclass == NULL)
320			return false;
321			if (operclass->flags & OPERCLASS_NEEDOPER && !is_ircop (u))
322			return false;
323			if (string_in_list (operclass->privs, priv))
324			return true;
325			}
326			return false;
327			}
328
329			bool
330	pippijn	1.4	has_priv_myuser (myuser_t mu, char const const priv)
331	pippijn	1.1	{
332			operclass_t *operclass;
333
334			if (priv == NULL)
335			return true;
336			if (mu == NULL)
337			return false;
338			if (!is_soper (mu))
339			return false;
340			operclass = mu->soper->operclass;
341			if (operclass == NULL)
342			return false;
343			if (string_in_list (operclass->privs, priv))
344			return true;
345			return false;
346			}
347
348			bool
349	pippijn	1.4	has_priv_operclass (operclass_t operclass, char const const priv)
350	pippijn	1.1	{
351			if (operclass == NULL)
352			return false;
353			if (string_in_list (operclass->privs, priv))
354			return true;
355			return false;
356			}
357
358			bool
359			has_all_operclass (sourceinfo_t si, operclass_t operclass)
360			{
361			char *privs2;
362			char *priv;
363
364			privs2 = sstrdup (operclass->privs);
365			priv = strtok (privs2, " ");
366			while (priv != NULL)
367			{
368			if (!has_priv (si, priv))
369			{
370	pippijn	1.4	sfree (privs2);
371	pippijn	1.1	return false;
372			}
373			priv = strtok (NULL, " ");
374			}
375	pippijn	1.4	sfree (privs2);
376	pippijn	1.1	return true;
377			}