]>
jfr.im git - irc/evilnet/x3.git/blob - src/gline.c
1 /* gline.c - Gline database
2 * Copyright 2000-2004 srvx Development Team
4 * This file is part of x3.
6 * x3 is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with srvx; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
28 #ifdef HAVE_SYS_SOCKET_H
29 #include <sys/socket.h>
31 #ifdef HAVE_NETINET_IN_H
32 #include <netinet/in.h>
34 #ifdef HAVE_ARPA_INET_H
35 #include <arpa/inet.h>
41 #define KEY_REASON "reason"
42 #define KEY_EXPIRES "expires"
43 #define KEY_ISSUER "issuer"
44 #define KEY_ISSUED "issued"
46 static heap_t gline_heap
; /* key: expiry time, data: struct gline_entry* */
47 static dict_t gline_dict
; /* key: target, data: struct gline_entry* */
50 gline_comparator(const void *a
, const void *b
)
52 const struct gline
*ga
=a
, *gb
=b
;
53 return ga
->expires
- gb
->expires
;
57 free_gline_from_dict(void *data
)
59 struct gline
*ent
= data
;
67 free_gline(struct gline
*ent
)
69 dict_remove(gline_dict
, ent
->target
);
73 gline_for_p(UNUSED_ARG(void *key
), void *data
, void *extra
)
75 struct gline
*ge
= data
;
76 return !irccasecmp(ge
->target
, extra
);
80 delete_gline_for_p(UNUSED_ARG(void *key
), void *data
, void *extra
)
82 struct gline
*ge
= data
;
84 if (!irccasecmp(ge
->target
, extra
)) {
93 gline_expire(UNUSED_ARG(void *data
))
99 while (heap_size(gline_heap
)) {
100 heap_peek(gline_heap
, 0, &wraa
);
101 stopped
= ((struct gline
*)wraa
)->expires
;
104 heap_pop(gline_heap
);
107 if (heap_size(gline_heap
))
108 timeq_add(stopped
, gline_expire
, NULL
);
112 gline_remove(const char *target
, int announce
)
114 int res
= dict_find(gline_dict
, target
, NULL
) ? 1 : 0;
115 if (heap_remove_pred(gline_heap
, delete_gline_for_p
, (char*)target
)) {
117 struct gline
*new_first
;
118 heap_peek(gline_heap
, 0, &argh
);
121 timeq_del(0, gline_expire
, 0, TIMEQ_IGNORE_WHEN
|TIMEQ_IGNORE_DATA
);
122 timeq_add(new_first
->expires
, gline_expire
, 0);
125 #ifdef WITH_PROTOCOL_BAHAMUT
126 /* Bahamut is sort of lame: It permanently remembers any AKILLs
127 * with durations longer than a day, and will never auto-expire
128 * them. So when the time comes, we'd better remind it. */
137 gline_add(const char *issuer
, const char *target
, unsigned long duration
, const char *reason
, time_t issued
, int announce
, int silent
)
140 struct gline
*prev_first
;
143 heap_peek(gline_heap
, 0, &argh
);
145 ent
= dict_find(gline_dict
, target
, NULL
);
147 heap_remove_pred(gline_heap
, gline_for_p
, (char*)target
);
148 if (ent
->expires
< (time_t)(now
+ duration
))
149 ent
->expires
= now
+ duration
;
151 ent
= malloc(sizeof(*ent
));
152 ent
->issued
= issued
;
153 ent
->issuer
= strdup(issuer
);
154 ent
->target
= strdup(target
);
155 ent
->expires
= now
+ duration
;
156 ent
->reason
= strdup(reason
);
157 dict_insert(gline_dict
, ent
->target
, ent
);
159 heap_insert(gline_heap
, ent
, ent
);
160 if (!prev_first
|| (ent
->expires
< prev_first
->expires
)) {
161 timeq_del(0, gline_expire
, 0, TIMEQ_IGNORE_WHEN
|TIMEQ_IGNORE_DATA
);
162 timeq_add(ent
->expires
, gline_expire
, 0);
165 irc_gline(NULL
, ent
, silent
);
170 gline_alternate_target(const char *target
)
172 const char *hostname
;
174 /* If no host part, bail. */
175 if (!(hostname
= strchr(target
, '@')))
177 /* If host part contains wildcards, bail. */
178 if (hostname
[strcspn(hostname
, "*?/")])
181 irc_in_addr_t in
; /* move this to the right place */
182 if (irc_pton(&in
, NULL
, hostname
+1)) {
183 if (getnameinfo(/*TODO*/))
185 } else if (!getaddrinfo(/*TODO*/)) {
193 gline_find(const char *target
)
199 res
= dict_find(gline_dict
, target
, NULL
);
202 /* Stock ircu requires BADCHANs to match exactly. */
203 if ((target
[0] == '#') || (target
[0] == '&'))
205 else if (target
[strcspn(target
, "*?")]) {
206 /* Wildcard: do an obnoxiously long search. */
207 for (it
= dict_first(gline_dict
); it
; it
= iter_next(it
)) {
209 if (match_ircglob(target
, res
->target
))
213 /* See if we can resolve the hostname part of the mask. */
214 if ((alt_target
= gline_alternate_target(target
))) {
215 res
= gline_find(alt_target
);
223 gline_refresh_helper(UNUSED_ARG(void *key
), void *data
, void *extra
)
225 struct gline
*ge
= data
;
226 irc_gline(extra
, ge
, 0);
231 gline_refresh_server(struct server
*srv
)
233 heap_remove_pred(gline_heap
, gline_refresh_helper
, srv
);
237 gline_refresh_all(void)
239 heap_remove_pred(gline_heap
, gline_refresh_helper
, 0);
245 return dict_size(gline_dict
);
249 gline_add_record(const char *key
, void *data
, UNUSED_ARG(void *extra
))
251 struct record_data
*rd
= data
;
252 const char *issuer
, *reason
, *dstr
;
253 time_t issued
, expiration
;
255 if (!(reason
= database_get_data(rd
->d
.object
, KEY_REASON
, RECDB_QSTRING
))) {
256 log_module(MAIN_LOG
, LOG_ERROR
, "Missing reason for gline %s", key
);
259 if (!(dstr
= database_get_data(rd
->d
.object
, KEY_EXPIRES
, RECDB_QSTRING
))) {
260 log_module(MAIN_LOG
, LOG_ERROR
, "Missing expiration for gline %s", key
);
263 expiration
= strtoul(dstr
, NULL
, 0);
264 if ((dstr
= database_get_data(rd
->d
.object
, KEY_ISSUED
, RECDB_QSTRING
))) {
265 issued
= strtoul(dstr
, NULL
, 0);
269 if (!(issuer
= database_get_data(rd
->d
.object
, KEY_ISSUER
, RECDB_QSTRING
))) {
270 issuer
= "<unknown>";
272 if (expiration
> now
)
273 gline_add(issuer
, key
, expiration
- now
, reason
, issued
, 0, 0);
278 gline_saxdb_read(struct dict
*db
)
280 return dict_foreach(db
, gline_add_record
, 0) != NULL
;
284 gline_write_entry(UNUSED_ARG(void *key
), void *data
, void *extra
)
286 struct gline
*ent
= data
;
287 struct saxdb_context
*ctx
= extra
;
289 saxdb_start_record(ctx
, ent
->target
, 0);
290 saxdb_write_int(ctx
, KEY_EXPIRES
, ent
->expires
);
291 saxdb_write_int(ctx
, KEY_ISSUED
, ent
->issued
);
292 saxdb_write_string(ctx
, KEY_REASON
, ent
->reason
);
293 saxdb_write_string(ctx
, KEY_ISSUER
, ent
->issuer
);
294 saxdb_end_record(ctx
);
299 gline_saxdb_write(struct saxdb_context
*ctx
)
301 heap_remove_pred(gline_heap
, gline_write_entry
, ctx
);
306 gline_db_cleanup(void)
308 heap_delete(gline_heap
);
309 dict_delete(gline_dict
);
315 gline_heap
= heap_new(gline_comparator
);
316 gline_dict
= dict_new();
317 dict_set_free_data(gline_dict
, free_gline_from_dict
);
318 saxdb_register("gline", gline_saxdb_read
, gline_saxdb_write
);
319 reg_exit_func(gline_db_cleanup
);
322 struct gline_discrim
*
323 gline_discrim_create(struct userNode
*user
, struct userNode
*src
, unsigned int argc
, char *argv
[])
326 struct gline_discrim
*discrim
;
328 discrim
= calloc(1, sizeof(*discrim
));
329 discrim
->max_issued
= now
;
332 for (i
=0; i
<argc
; i
++) {
334 send_message(user
, src
, "MSG_MISSING_PARAMS", argv
[i
]);
336 } else if (!irccasecmp(argv
[i
], "mask") || !irccasecmp(argv
[i
], "host")) {
337 if (!irccasecmp(argv
[++i
], "exact"))
338 discrim
->target_mask_type
= EXACT
;
339 else if (!irccasecmp(argv
[i
], "subset"))
340 discrim
->target_mask_type
= SUBSET
;
341 else if (!irccasecmp(argv
[i
], "superset"))
342 discrim
->target_mask_type
= SUPERSET
;
344 discrim
->target_mask_type
= SUBSET
, i
--;
346 send_message(user
, src
, "MSG_MISSING_PARAMS", argv
[i
-1]);
349 if (!is_gline(argv
[i
]) && !IsChannelName(argv
[i
])) {
350 send_message(user
, src
, "MSG_INVALID_GLINE", argv
[i
]);
353 discrim
->target_mask
= argv
[i
];
354 discrim
->alt_target_mask
= gline_alternate_target(discrim
->target_mask
);
355 } else if (!irccasecmp(argv
[i
], "limit"))
356 discrim
->limit
= strtoul(argv
[++i
], NULL
, 0);
357 else if (!irccasecmp(argv
[i
], "reason"))
358 discrim
->reason_mask
= argv
[++i
];
359 else if (!irccasecmp(argv
[i
], "issuer"))
360 discrim
->issuer_mask
= argv
[++i
];
361 else if (!irccasecmp(argv
[i
], "after"))
362 discrim
->min_expire
= now
+ ParseInterval(argv
[++i
]);
363 else if (!irccasecmp(argv
[i
], "before"))
364 discrim
->max_issued
= now
- ParseInterval(argv
[++i
]);
366 send_message(user
, src
, "MSG_INVALID_CRITERIA", argv
[i
]);
372 free(discrim
->alt_target_mask
);
377 struct gline_search
{
378 struct gline_discrim
*discrim
;
379 gline_search_func func
;
385 gline_discrim_match(struct gline
*gline
, struct gline_discrim
*discrim
)
387 if ((discrim
->issuer_mask
&& !match_ircglob(gline
->issuer
, discrim
->issuer_mask
))
388 || (discrim
->reason_mask
&& !match_ircglob(gline
->reason
, discrim
->reason_mask
))
389 || (discrim
->target_mask
390 && (((discrim
->target_mask_type
== SUBSET
)
391 && !match_ircglobs(discrim
->target_mask
, gline
->target
)
392 && (!discrim
->alt_target_mask
393 || !match_ircglobs(discrim
->alt_target_mask
, gline
->target
)))
394 || ((discrim
->target_mask_type
== EXACT
)
395 && irccasecmp(discrim
->target_mask
, gline
->target
)
396 && (!discrim
->alt_target_mask
397 || !irccasecmp(discrim
->alt_target_mask
, gline
->target
)))
398 || ((discrim
->target_mask_type
== SUPERSET
)
399 && !match_ircglobs(gline
->target
, discrim
->target_mask
)
400 && (!discrim
->alt_target_mask
401 || !match_ircglobs(discrim
->alt_target_mask
, gline
->target
)))))
402 || (discrim
->max_issued
< gline
->issued
)
403 || (discrim
->min_expire
> gline
->expires
)) {
410 gline_search_helper(UNUSED_ARG(void *key
), void *data
, void *extra
)
412 struct gline
*gline
= data
;
413 struct gline_search
*search
= extra
;
415 if (gline_discrim_match(gline
, search
->discrim
)
416 && (search
->hits
++ < search
->discrim
->limit
)) {
417 search
->func(gline
, search
->data
);
423 gline_discrim_search(struct gline_discrim
*discrim
, gline_search_func gsf
, void *data
)
425 struct gline_search search
;
426 search
.discrim
= discrim
;
430 heap_remove_pred(gline_heap
, gline_search_helper
, &search
);