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
|
/* entities.c - entity tracking
* Copyright (C) 2010 Atheme Development Group
*/
#include "atheme.h"
static mowgli_patricia_t *entities;
void init_entities(void)
{
entities = mowgli_patricia_create(irccasecanon);
}
void myentity_put(myentity_t *mt)
{
mowgli_patricia_add(entities, mt->name, mt);
}
void myentity_del(myentity_t *mt)
{
mowgli_patricia_delete(entities, mt->name);
}
myentity_t *myentity_find(const char *name)
{
return mowgli_patricia_retrieve(entities, name);
}
myentity_t *myentity_find_ext(const char *name)
{
myentity_t *mt;
mt = entity(myuser_find_ext(name));
if (mt != NULL)
return mt;
return myentity_find(name);
}
void myentity_foreach_start(myentity_iteration_state_t *state, myentity_type_t type)
{
myentity_t *e;
state->type = type;
mowgli_patricia_foreach_start(entities, &state->st);
e = mowgli_patricia_foreach_cur(entities, &state->st);
while (e && state->type != ENT_ANY && state->type != e->type)
{
mowgli_patricia_foreach_next(entities, &state->st);
e = mowgli_patricia_foreach_cur(entities, &state->st);
}
}
myentity_t *myentity_foreach_cur(myentity_iteration_state_t *state)
{
return mowgli_patricia_foreach_cur(entities, &state->st);
}
void myentity_foreach_next(myentity_iteration_state_t *state)
{
myentity_t *e;
do {
mowgli_patricia_foreach_next(entities, &state->st);
e = mowgli_patricia_foreach_cur(entities, &state->st);
} while (e && state->type != ENT_ANY && state->type != e->type);
}
void myentity_foreach(int (*cb)(myentity_t *mt, void *privdata), void *privdata)
{
myentity_foreach_t(ENT_ANY, cb, privdata);
}
void myentity_foreach_t(myentity_type_t type, int (*cb)(myentity_t *mt, void *privdata), void *privdata)
{
myentity_iteration_state_t state;
myentity_t *mt;
MYENTITY_FOREACH_T(mt, &state, type)
{
if (cb(mt, privdata))
return;
}
}
void myentity_stats(void (*cb)(const char *line, void *privdata), void *privdata)
{
mowgli_patricia_stats(entities, cb, privdata);
}
/* validation */
static chanacs_t *linear_chanacs_match_entity(chanacs_t *ca, myentity_t *mt)
{
return ca->entity == mt ? ca : NULL;
}
static bool linear_can_register_channel(myentity_t *mt)
{
myuser_t *mu;
if ((mu = user(mt)) == NULL)
return false;
if (mu->flags & MU_REGNOLIMIT)
return true;
return has_priv_myuser(mu, PRIV_REG_NOLIMIT);
}
entity_chanacs_validation_vtable_t linear_chanacs_validate = {
.match_entity = linear_chanacs_match_entity,
.can_register_channel = linear_can_register_channel,
};
entity_chanacs_validation_vtable_t *myentity_get_chanacs_validator(myentity_t *mt)
{
return mt->chanacs_validate != NULL ? mt->chanacs_validate : &linear_chanacs_validate;
}
/* chanacs */
unsigned int myentity_count_channels_with_flagset(myentity_t *mt, unsigned int flagset)
{
mowgli_node_t *n;
chanacs_t *ca;
unsigned int count = 0;
MOWGLI_ITER_FOREACH(n, mt->chanacs.head)
{
ca = n->data;
if (ca->level & flagset)
count++;
}
return count;
}
bool myentity_can_register_channel(myentity_t *mt)
{
entity_chanacs_validation_vtable_t *vt;
return_val_if_fail(mt != NULL, false);
vt = myentity_get_chanacs_validator(mt);
if (vt->can_register_channel(mt))
return true;
return (myentity_count_channels_with_flagset(mt, CA_FOUNDER) < me.maxchans);
}
|
