1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/**
* \file privtab.c
*
* \brief Privilege tables for PennMUSH.
*
* A privilege table is a respresentation of different privilege
* flags with associated names, characters, and bitmasks.
*
*/
#include "copyrite.h"
#include "config.h"
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "conf.h"
#include "privtab.h"
#include "externs.h"
#include "confmagic.h"
/** Convert a string to a set of privilege bits, masked by an original set.
* Given a privs table, a string, and an original set of privileges,
* return a modified set of privileges by applying the privs in the
* string to the original set of privileges.
* \param table pointer to a privtab.
* \param str a space-separated string of privilege names to apply.
* \param origprivs the original privileges.
* \return a privilege bitmask.
*/
int
string_to_privs(PRIV *table, const char *str, long int origprivs)
{
PRIV *c;
long int yes = 0;
long int no = 0;
char *p, *r;
char tbuf1[BUFFER_LEN];
int not;
int words = 0;
if (!str || !*str)
return origprivs;
strcpy(tbuf1, str);
r = trim_space_sep(tbuf1, ' ');
while ((p = split_token(&r, ' '))) {
words++;
not = 0;
if (*p == '!') {
not = 1;
if (!*++p)
continue;
}
for (c = table; c->name; c++) {
if (string_prefix(c->name, p)) {
if (not)
no |= c->bits_to_set;
else
yes |= c->bits_to_set;
break;
}
}
}
/* If we made no changes, and were given one word,
* we probably were given letters instead */
if (!no && !yes && (words == 1))
return letter_to_privs(table, str, origprivs);
return ((origprivs | yes) & ~no);
}
/** Convert a letter string to a set of privilege bits, masked by an original set.
* Given a privs table, a letter string, and an original set of privileges,
* return a modified set of privileges by applying the privs in the
* string to the original set of privileges.
* \param table pointer to a privtab.
* \param str a string of privilege letters to apply.
* \param origprivs the original privileges.
* \return a privilege bitmask.
*/
int
letter_to_privs(PRIV *table, const char *str, long int origprivs)
{
PRIV *c;
long int yes = 0, no = 0;
const char *p;
int not;
if (!str || !*str)
return origprivs;
for (p = str; *p; p++) {
not = 0;
if (*p == '!') {
not = 1;
if (!*++p)
break;
}
for (c = table; c->name; c++) {
if (c->letter == *p) {
if (not)
no |= c->bits_to_set;
else
yes |= c->bits_to_set;
break;
}
}
}
return ((origprivs | yes) & ~no);
}
/** Given a table and a bitmask, return a privs string (static allocation).
* \param table pointer to a privtab.
* \param privs bitmask of privileges.
* \return statically allocated space-separated string of priv names.
*/
const char *
privs_to_string(PRIV *table, int privs)
{
PRIV *c;
static char buf[BUFFER_LEN];
char *bp;
bp = buf;
for (c = table; c->name; c++) {
if (privs & c->bits_to_show) {
if (bp != buf)
safe_chr(' ', buf, &bp);
safe_str(c->name, buf, &bp);
privs &= ~c->bits_to_set;
}
}
*bp = '\0';
return buf;
}
/** Given a table and a bitmask, return a privs letter string (static allocation).
* \param table pointer to a privtab.
* \param privs bitmask of privileges.
* \return statically allocated string of priv letters.
*/
const char *
privs_to_letters(PRIV *table, int privs)
{
PRIV *c;
static char buf[BUFFER_LEN];
char *bp;
bp = buf;
for (c = table; c->name; c++) {
if ((privs & c->bits_to_show) && c->letter) {
safe_chr(c->letter, buf, &bp);
privs &= ~c->bits_to_set;
}
}
*bp = '\0';
return buf;
}
|
