ermyth/src/flags.C

/*
 * flags.C: Functions to convert a flags table into a bitmask.
 * 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: flags.C,v 1.5 2007-08-30 19:56:24 pippijn Exp $";

#include "atheme.h"
#include <account/chanacs.h>

#define FLAGS_ADD       0x1
#define FLAGS_DEL       0x2

unsigned int ca_all = CA_ALL_ALL;

static char flags_buf[128];

flags_table chanacs_flags[] = {
  { 'v', CA_VOICE      },
  { 'V', CA_AUTOVOICE  },
  { 'o', CA_OP         },
  { 'O', CA_AUTOOP     },
  { 't', CA_TOPIC      },
  { 's', CA_SET        },
  { 'r', CA_REMOVE     },
  { 'i', CA_INVITE     },
  { 'R', CA_RECOVER    },
  { 'f', CA_FLAGS      },
  { 'h', CA_HALFOP     },
  { 'H', CA_AUTOHALFOP },
  { 'A', CA_ACLVIEW    },
  { 'F', CA_FOUNDER    },
  { 'b', CA_AKICK      },
  { 0, 0 }
};

/* Construct bitmasks to be added and removed
 * Postcondition *addflags & *removeflags == 0
 * -- jilles */
void
flags_make_bitmasks (char const * const string, struct flags_table table[], unsigned int *addflags, unsigned int *removeflags)
{
  int status = FLAGS_ADD;
  char const *s = string;
  short i = 0;

  *addflags = *removeflags = 0;
  while (*s)
    {
      switch (*s)
        {
        case '+':
          status = FLAGS_ADD;
          break;

        case '-':
          status = FLAGS_DEL;
          break;

        case '=':
          *addflags = 0;
          *removeflags = 0xFFFFFFFF;
          status = FLAGS_ADD;
          break;

        case '*':
          if (status == FLAGS_ADD)
            {
              *addflags = 0xFFFFFFFF;
              *removeflags = 0;

              /* If this is chanacs_flags[], remove the ban flag. */
              if (table == chanacs_flags)
                {
                  *addflags &= ~CA_FOUNDER;
                  *removeflags |= CA_AKICK;
                }
            }
          else if (status == FLAGS_DEL)
            {
              *addflags = 0;
              *removeflags = 0xFFFFFFFF;
            }
          break;

        default:
          for (i = 0; table[i].flag; i++)
            if (table[i].flag == *s)
              {
                if (status == FLAGS_ADD)
                  {
                    *addflags |= table[i].value;
                    *removeflags &= ~table[i].value;
                  }
                else if (status == FLAGS_DEL)
                  {
                    *addflags &= ~table[i].value;
                    *removeflags |= table[i].value;
                  }
              }
        }

      (void) *s++;
    }

  return;
}

unsigned int
flags_to_bitmask (char const * const string, struct flags_table table[], unsigned int flags)
{
  int bitmask = (flags ? flags : 0x0);
  int status = FLAGS_ADD;
  char const *s = string;
  short i = 0;

  while (*s)
    {
      switch (*s)
        {
        case '+':
          status = FLAGS_ADD;
          break;

        case '-':
          status = FLAGS_DEL;
          break;

        case '=':
          bitmask = 0;
          status = FLAGS_ADD;
          break;

        case '*':
          if (status == FLAGS_ADD)
            {
              bitmask = 0xFFFFFFFF;

              /* If this is chanacs_flags[], do privs only */
              if (table == chanacs_flags)
                bitmask &= CA_ALLPRIVS & ca_all & ~CA_FOUNDER;
            }
          else if (status == FLAGS_DEL)
            bitmask = 0;
          break;

        default:
          for (i = 0; table[i].flag; i++)
            if (table[i].flag == *s)
              {
                if (status == FLAGS_ADD)
                  bitmask |= table[i].value;
                else if (status == FLAGS_DEL)
                  bitmask &= ~table[i].value;
              }
        }

      (void) *s++;
    }

  return bitmask;
}

char *
bitmask_to_flags (unsigned int flags, struct flags_table table[])
{
  char *bptr;
  short i = 0;

  bptr = flags_buf;

  *bptr++ = '+';

  for (i = 0; table[i].flag; i++)
    if (table[i].value & flags)
      *bptr++ = table[i].flag;

  *bptr++ = '\0';

  return flags_buf;
}

char *
bitmask_to_flags2 (unsigned int addflags, unsigned int removeflags, struct flags_table table[])
{
  char *bptr;
  short i = 0;

  bptr = flags_buf;

  if (removeflags)
    {
      *bptr++ = '-';
      for (i = 0; table[i].flag; i++)
        if (table[i].value & removeflags)
          *bptr++ = table[i].flag;
    }
  if (addflags)
    {
      *bptr++ = '+';
      for (i = 0; table[i].flag; i++)
        if (table[i].value & addflags)
          *bptr++ = table[i].flag;
    }

  *bptr++ = '\0';

  return flags_buf;
}

/* flags a non-founder with +f and these flags is allowed to set -- jilles */
unsigned int
allow_flags (unsigned int flags)
{
  flags &= ~CA_AKICK;
  if (flags & CA_REMOVE)
    flags |= CA_AKICK;
  if (flags & CA_OP)
    flags |= CA_AUTOOP;
  if (flags & CA_HALFOP)
    flags |= CA_AUTOHALFOP;
  if (flags & CA_VOICE)
    flags |= CA_AUTOVOICE;
  return flags;
}

void
update_chanacs_flags (void)
{
  ca_all = CA_ALL_ALL;
  if (!ircd->uses_halfops)
    ca_all &= ~(CA_HALFOP | CA_AUTOHALFOP);
}
Revision:	1.6
Committed:	Wed Sep 5 11:23:15 2007 UTC (16 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+1 -7 lines
Log Message:	removed GPLed code and put license back to BSD
#	User	Rev	Content
1	pippijn	1.1	/*
2			* flags.C: Functions to convert a flags table into a bitmask.
3	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
4	pippijn	1.1	*
5	pippijn	1.4	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
6	pippijn	1.1	*/
7
8	pippijn	1.6	static char const rcsid[] = "$Id: flags.C,v 1.5 2007-08-30 19:56:24 pippijn Exp $";
9	pippijn	1.1
10			#include "atheme.h"
11			#include <account/chanacs.h>
12
13			#define FLAGS_ADD 0x1
14			#define FLAGS_DEL 0x2
15
16			unsigned int ca_all = CA_ALL_ALL;
17
18			static char flags_buf[128];
19
20	pippijn	1.5	flags_table chanacs_flags[] = {
21			{ 'v', CA_VOICE },
22			{ 'V', CA_AUTOVOICE },
23			{ 'o', CA_OP },
24			{ 'O', CA_AUTOOP },
25			{ 't', CA_TOPIC },
26			{ 's', CA_SET },
27			{ 'r', CA_REMOVE },
28			{ 'i', CA_INVITE },
29			{ 'R', CA_RECOVER },
30			{ 'f', CA_FLAGS },
31			{ 'h', CA_HALFOP },
32			{ 'H', CA_AUTOHALFOP },
33			{ 'A', CA_ACLVIEW },
34			{ 'F', CA_FOUNDER },
35			{ 'b', CA_AKICK },
36			{ 0, 0 }
37	pippijn	1.1	};
38
39			/* Construct bitmasks to be added and removed
40			* Postcondition addflags & removeflags == 0
41			* -- jilles */
42			void
43	pippijn	1.4	flags_make_bitmasks (char const * const string, struct flags_table table[], unsigned int addflags, unsigned int removeflags)
44	pippijn	1.1	{
45			int status = FLAGS_ADD;
46	pippijn	1.4	char const *s = string;
47	pippijn	1.1	short i = 0;
48
49			addflags = removeflags = 0;
50	pippijn	1.4	while (*s)
51	pippijn	1.1	{
52	pippijn	1.4	switch (*s)
53	pippijn	1.1	{
54			case '+':
55			status = FLAGS_ADD;
56			break;
57
58			case '-':
59			status = FLAGS_DEL;
60			break;
61
62			case '=':
63			*addflags = 0;
64			*removeflags = 0xFFFFFFFF;
65			status = FLAGS_ADD;
66			break;
67
68			case '*':
69			if (status == FLAGS_ADD)
70			{
71			*addflags = 0xFFFFFFFF;
72			*removeflags = 0;
73
74			/* If this is chanacs_flags[], remove the ban flag. */
75			if (table == chanacs_flags)
76			{
77	pippijn	1.4	*addflags &= ~CA_FOUNDER;
78	pippijn	1.1	*removeflags \|= CA_AKICK;
79			}
80			}
81			else if (status == FLAGS_DEL)
82			{
83			*addflags = 0;
84			*removeflags = 0xFFFFFFFF;
85			}
86			break;
87
88			default:
89			for (i = 0; table[i].flag; i++)
90	pippijn	1.4	if (table[i].flag == *s)
91	pippijn	1.1	{
92			if (status == FLAGS_ADD)
93			{
94			*addflags \|= table[i].value;
95			*removeflags &= ~table[i].value;
96			}
97			else if (status == FLAGS_DEL)
98			{
99			*addflags &= ~table[i].value;
100			*removeflags \|= table[i].value;
101			}
102			}
103			}
104
105	pippijn	1.4	(void) *s++;
106	pippijn	1.1	}
107
108			return;
109			}
110
111			unsigned int
112	pippijn	1.4	flags_to_bitmask (char const * const string, struct flags_table table[], unsigned int flags)
113	pippijn	1.1	{
114			int bitmask = (flags ? flags : 0x0);
115			int status = FLAGS_ADD;
116	pippijn	1.4	char const *s = string;
117	pippijn	1.1	short i = 0;
118
119	pippijn	1.4	while (*s)
120	pippijn	1.1	{
121	pippijn	1.4	switch (*s)
122	pippijn	1.1	{
123			case '+':
124			status = FLAGS_ADD;
125			break;
126
127			case '-':
128			status = FLAGS_DEL;
129			break;
130
131			case '=':
132			bitmask = 0;
133			status = FLAGS_ADD;
134			break;
135
136			case '*':
137			if (status == FLAGS_ADD)
138			{
139			bitmask = 0xFFFFFFFF;
140
141			/* If this is chanacs_flags[], do privs only */
142			if (table == chanacs_flags)
143	pippijn	1.4	bitmask &= CA_ALLPRIVS & ca_all & ~CA_FOUNDER;
144	pippijn	1.1	}
145			else if (status == FLAGS_DEL)
146			bitmask = 0;
147			break;
148
149			default:
150			for (i = 0; table[i].flag; i++)
151	pippijn	1.4	if (table[i].flag == *s)
152	pippijn	1.1	{
153			if (status == FLAGS_ADD)
154			bitmask \|= table[i].value;
155			else if (status == FLAGS_DEL)
156			bitmask &= ~table[i].value;
157			}
158			}
159
160	pippijn	1.4	(void) *s++;
161	pippijn	1.1	}
162
163			return bitmask;
164			}
165
166			char *
167			bitmask_to_flags (unsigned int flags, struct flags_table table[])
168			{
169			char *bptr;
170			short i = 0;
171
172			bptr = flags_buf;
173
174			*bptr++ = '+';
175
176			for (i = 0; table[i].flag; i++)
177			if (table[i].value & flags)
178			*bptr++ = table[i].flag;
179
180			*bptr++ = '\0';
181
182			return flags_buf;
183			}
184
185			char *
186			bitmask_to_flags2 (unsigned int addflags, unsigned int removeflags, struct flags_table table[])
187			{
188			char *bptr;
189			short i = 0;
190
191			bptr = flags_buf;
192
193			if (removeflags)
194			{
195			*bptr++ = '-';
196			for (i = 0; table[i].flag; i++)
197			if (table[i].value & removeflags)
198			*bptr++ = table[i].flag;
199			}
200			if (addflags)
201			{
202			*bptr++ = '+';
203			for (i = 0; table[i].flag; i++)
204			if (table[i].value & addflags)
205			*bptr++ = table[i].flag;
206			}
207
208			*bptr++ = '\0';
209
210			return flags_buf;
211			}
212
213			/* flags a non-founder with +f and these flags is allowed to set -- jilles */
214			unsigned int
215			allow_flags (unsigned int flags)
216			{
217			flags &= ~CA_AKICK;
218			if (flags & CA_REMOVE)
219			flags \|= CA_AKICK;
220			if (flags & CA_OP)
221			flags \|= CA_AUTOOP;
222			if (flags & CA_HALFOP)
223			flags \|= CA_AUTOHALFOP;
224			if (flags & CA_VOICE)
225			flags \|= CA_AUTOVOICE;
226			return flags;
227			}
228
229			void
230			update_chanacs_flags (void)
231			{
232			ca_all = CA_ALL_ALL;
233			if (!ircd->uses_halfops)
234			ca_all &= ~(CA_HALFOP \| CA_AUTOHALFOP);
235			}