[irc/evilnet/x3.git] / src / shun.c

/* shun.c - Shun database
 * Copyright 2000-2004 srvx Development Team
 *
 * This file is part of x3.
 *
 * srvx is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with srvx; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

#include "heap.h"
#include "helpfile.h"
#include "log.h"
#include "saxdb.h"
#include "timeq.h"
#include "shun.h"

#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif

#define KEY_REASON "reason"
#define KEY_EXPIRES "expires"
#define KEY_ISSUER "issuer"
#define KEY_ISSUED "issued"

static heap_t shun_heap; /* key: expiry time, data: struct shun_entry* */
static dict_t shun_dict; /* key: target, data: struct shun_entry* */

static int
shun_comparator(const void *a, const void *b)
{
    const struct shun *ga=a, *gb=b;
    return ga->expires - gb->expires;
}

static void
free_shun_from_dict(void *data)
{
    struct shun *ent = data;
    free(ent->issuer);
    free(ent->target);
    free(ent->reason);
    free(ent);
}

static void
free_shun(struct shun *ent)
{
    dict_remove(shun_dict, ent->target);
}

static int
shun_for_p(UNUSED_ARG(void *key), void *data, void *extra)
{
    struct shun *ge = data;
    return !irccasecmp(ge->target, extra);
}

static int
delete_shun_for_p(UNUSED_ARG(void *key), void *data, void *extra)
{
    struct shun *ge = data;

    if (!irccasecmp(ge->target, extra)) {
        free_shun(ge);
        return 1;
    } else {
        return 0;
    }
}

static void
shun_expire(UNUSED_ARG(void *data))
{
    time_t stopped;
    void *wraa;

    stopped = 0;
    while (heap_size(shun_heap)) {
        heap_peek(shun_heap, 0, &wraa);
        stopped = ((struct shun*)wraa)->expires;
        if (stopped > now)
            break;
        heap_pop(shun_heap);
        free_shun(wraa);
    }
    if (heap_size(shun_heap))
        timeq_add(stopped, shun_expire, NULL);
}

int
shun_remove(const char *target, int announce)
{
    int res = dict_find(shun_dict, target, NULL) ? 1 : 0;
    if (heap_remove_pred(shun_heap, delete_shun_for_p, (char*)target)) {
        void *argh;
        struct shun *new_first;
        heap_peek(shun_heap, 0, &argh);
        if (argh) {
            new_first = argh;
            timeq_del(0, shun_expire, 0, TIMEQ_IGNORE_WHEN|TIMEQ_IGNORE_DATA);
            timeq_add(new_first->expires, shun_expire, 0);
        }
    }
#ifdef WITH_PROTOCOL_BAHAMUT
    /* Bahamut is sort of lame: It permanently remembers any AKILLs
     * with durations longer than a day, and will never auto-expire
     * them.  So when the time comes, we'd better remind it.  */
    announce = 1;
#endif
    if (announce)
        irc_unshun(target);
    return res;
}

struct shun *
shun_add(const char *issuer, const char *target, unsigned long duration, const char *reason, time_t issued, int announce)
{
    struct shun *ent;
    struct shun *prev_first;
    void *argh;

    heap_peek(shun_heap, 0, &argh);
    prev_first = argh;
    ent = dict_find(shun_dict, target, NULL);
    if (ent) {
        heap_remove_pred(shun_heap, shun_for_p, (char*)target);
        if (ent->expires < (time_t)(now + duration))
            ent->expires = now + duration;
    } else {
        ent = malloc(sizeof(*ent));
        ent->issued = issued;
        ent->issuer = strdup(issuer);
        ent->target = strdup(target);
        ent->expires = now + duration;
        ent->reason = strdup(reason);
        dict_insert(shun_dict, ent->target, ent);
    }
    heap_insert(shun_heap, ent, ent);
    if (!prev_first || (ent->expires < prev_first->expires)) {
	timeq_del(0, shun_expire, 0, TIMEQ_IGNORE_WHEN|TIMEQ_IGNORE_DATA);
	timeq_add(ent->expires, shun_expire, 0);
    }
    if (announce)
        irc_shun(NULL, ent);
    return ent;
}

static char *
shun_alternate_target(const char *target)
{
    const char *hostname;

    /* If no host part, bail. */
    if (!(hostname = strchr(target, '@')))
        return NULL;
    /* If host part contains wildcards, bail. */
    if (hostname[strcspn(hostname, "*?/")])
        return NULL;
    /* Get parsed address and canonical name for host. */
#if 0
    irc_in_addr_t in; /* move this to the right place */
    if (irc_pton(&in, NULL, hostname+1)) {
        if (getnameinfo(/*TODO*/))
              return NULL;
    } else if (!getaddrinfo(/*TODO*/)) {
    } else return NULL;
#else
    return NULL;
#endif
}

struct shun *
shun_find(const char *target)
{
    struct shun *res;
    dict_iterator_t it;
    char *alt_target;

    res = dict_find(shun_dict, target, NULL);
    if (res)
        return res;
    /* Stock ircu requires BADCHANs to match exactly. */
    if ((target[0] == '#') || (target[0] == '&'))
        return NULL;
    else if (target[strcspn(target, "*?")]) {
        /* Wildcard: do an obnoxiously long search. */
        for (it = dict_first(shun_dict); it; it = iter_next(it)) {
            res = iter_data(it);
            if (match_ircglob(target, res->target))
                return res;
        }
    }
    /* See if we can resolve the hostname part of the mask. */
    if ((alt_target = shun_alternate_target(target))) {
        res = shun_find(alt_target);
        free(alt_target);
        return res;
    }
    return NULL;
}

static int
shun_refresh_helper(UNUSED_ARG(void *key), void *data, void *extra)
{
    struct shun *ge = data;
    irc_shun(extra, ge);
    return 0;
}

void
shun_refresh_server(struct server *srv)
{
    heap_remove_pred(shun_heap, shun_refresh_helper, srv);
}

void
shun_refresh_all(void)
{
    heap_remove_pred(shun_heap, shun_refresh_helper, 0);
}

unsigned int
shun_count(void)
{
    return dict_size(shun_dict);
}

static int
shun_add_record(const char *key, void *data, UNUSED_ARG(void *extra))
{
    struct record_data *rd = data;
    const char *issuer, *reason, *dstr;
    time_t issued, expiration;

    if (!(reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING))) {
	log_module(MAIN_LOG, LOG_ERROR, "Missing reason for shun %s", key);
	return 0;
    }
    if (!(dstr = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING))) {
	log_module(MAIN_LOG, LOG_ERROR, "Missing expiration for shun %s", key);
	return 0;
    }
    expiration = strtoul(dstr, NULL, 0);
    if ((dstr = database_get_data(rd->d.object, KEY_ISSUED, RECDB_QSTRING))) {
        issued = strtoul(dstr, NULL, 0);
    } else {
        issued = now;
    }
    if (!(issuer = database_get_data(rd->d.object, KEY_ISSUER, RECDB_QSTRING))) {
        issuer = "<unknown>";
    }
    if (expiration > now)
        shun_add(issuer, key, expiration - now, reason, issued, 0);
    return 0;
}

static int
shun_saxdb_read(struct dict *db)
{
    return dict_foreach(db, shun_add_record, 0) != NULL;
}

static int
shun_write_entry(UNUSED_ARG(void *key), void *data, void *extra)
{
    struct shun *ent = data;
    struct saxdb_context *ctx = extra;

    saxdb_start_record(ctx, ent->target, 0);
    saxdb_write_int(ctx, KEY_EXPIRES, ent->expires);
    saxdb_write_int(ctx, KEY_ISSUED, ent->issued);
    saxdb_write_string(ctx, KEY_REASON, ent->reason);
    saxdb_write_string(ctx, KEY_ISSUER, ent->issuer);
    saxdb_end_record(ctx);
    return 0;
}

static int
shun_saxdb_write(struct saxdb_context *ctx)
{
    heap_remove_pred(shun_heap, shun_write_entry, ctx);
    return 0;
}

static void
shun_db_cleanup(void)
{
    heap_delete(shun_heap);
    dict_delete(shun_dict);
}

void
shun_init(void)
{
    shun_heap = heap_new(shun_comparator);
    shun_dict = dict_new();
    dict_set_free_data(shun_dict, free_shun_from_dict);
    saxdb_register("shun", shun_saxdb_read, shun_saxdb_write);
    reg_exit_func(shun_db_cleanup);
}

struct shun_discrim *
shun_discrim_create(struct userNode *user, struct userNode *src, unsigned int argc, char *argv[])
{
    unsigned int i;
    struct shun_discrim *discrim;

    discrim = calloc(1, sizeof(*discrim));
    discrim->max_issued = now;
    discrim->limit = 50;

    for (i=0; i<argc; i++) {
        if (i + 2 > argc) {
            send_message(user, src, "MSG_MISSING_PARAMS", argv[i]);
            goto fail;
        } else if (!irccasecmp(argv[i], "mask") || !irccasecmp(argv[i], "host")) {
            if (!irccasecmp(argv[++i], "exact"))
                discrim->target_mask_type = SEXACT;
            else if (!irccasecmp(argv[i], "subset"))
                discrim->target_mask_type = SSUBSET;
            else if (!irccasecmp(argv[i], "superset"))
                discrim->target_mask_type = SSUPERSET;
            else
                discrim->target_mask_type = SSUBSET, i--;
            if (++i == argc) {
                send_message(user, src, "MSG_MISSING_PARAMS", argv[i-1]);
                goto fail;
            }
            if (!is_shun(argv[i]) && !IsChannelName(argv[i])) {
                send_message(user, src, "MSG_INVALID_SHUN", argv[i]);
                goto fail;
            }
            discrim->target_mask = argv[i];
            discrim->alt_target_mask = shun_alternate_target(discrim->target_mask);
        } else if (!irccasecmp(argv[i], "limit"))
            discrim->limit = strtoul(argv[++i], NULL, 0);
        else if (!irccasecmp(argv[i], "reason"))
            discrim->reason_mask = argv[++i];
        else if (!irccasecmp(argv[i], "issuer"))
            discrim->issuer_mask = argv[++i];
        else if (!irccasecmp(argv[i], "after"))
            discrim->min_expire = now + ParseInterval(argv[++i]);
        else if (!irccasecmp(argv[i], "before"))
            discrim->max_issued = now - ParseInterval(argv[++i]);
        else {
            send_message(user, src, "MSG_INVALID_CRITERIA", argv[i]);
            goto fail;
        }
    }
    return discrim;
  fail:
    free(discrim->alt_target_mask);
    free(discrim);
    return NULL;
}

struct shun_search {
    struct shun_discrim *discrim;
    shun_search_func func;
    void *data;
    unsigned int hits;
};

static int
shun_discrim_match(struct shun *shun, struct shun_discrim *discrim)
{
    if ((discrim->issuer_mask && !match_ircglob(shun->issuer, discrim->issuer_mask))
        || (discrim->reason_mask && !match_ircglob(shun->reason, discrim->reason_mask))
        || (discrim->target_mask
            && (((discrim->target_mask_type == SSUBSET)
                 && !match_ircglobs(discrim->target_mask, shun->target)
                 && (!discrim->alt_target_mask
                     || !match_ircglobs(discrim->alt_target_mask, shun->target)))
                || ((discrim->target_mask_type == SEXACT)
                    && irccasecmp(discrim->target_mask, shun->target)
                    && (!discrim->alt_target_mask
                        || !irccasecmp(discrim->alt_target_mask, shun->target)))
                || ((discrim->target_mask_type == SSUPERSET)
                    && !match_ircglobs(shun->target, discrim->target_mask)
                    && (!discrim->alt_target_mask
                        || !match_ircglobs(discrim->alt_target_mask, shun->target)))))
        || (discrim->max_issued < shun->issued)
        || (discrim->min_expire > shun->expires)) {
        return 0;
    }
    return 1;
}

static int
shun_search_helper(UNUSED_ARG(void *key), void *data, void *extra)
{
    struct shun *shun = data;
    struct shun_search *search = extra;

    if (shun_discrim_match(shun, search->discrim)
        && (search->hits++ < search->discrim->limit)) {
        search->func(shun, search->data);
    }
    return 0;
}

unsigned int
shun_discrim_search(struct shun_discrim *discrim, shun_search_func gsf, void *data)
{
    struct shun_search search;
    search.discrim = discrim;
    search.func = gsf;
    search.data = data;
    search.hits = 0;
    heap_remove_pred(shun_heap, shun_search_helper, &search);
    return search.hits;
}
Commit	Line	Data
d914d1cb	1	/* shun.c - Shun database
	2	* Copyright 2000-2004 srvx Development Team
	3	*
	4	* This file is part of x3.
	5	*
	6	* srvx 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.
	10	*
	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.
	15	*
	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.
	19	*/
	20
	21	#include "heap.h"
	22	#include "helpfile.h"
	23	#include "log.h"
	24	#include "saxdb.h"
	25	#include "timeq.h"
	26	#include "shun.h"
	27
	28	#ifdef HAVE_SYS_SOCKET_H
	29	#include <sys/socket.h>
	30	#endif
	31	#ifdef HAVE_NETINET_IN_H
	32	#include <netinet/in.h>
	33	#endif
	34	#ifdef HAVE_ARPA_INET_H
	35	#include <arpa/inet.h>
	36	#endif
	37	#ifdef HAVE_NETDB_H
	38	#include <netdb.h>
	39	#endif
	40
	41	#define KEY_REASON "reason"
	42	#define KEY_EXPIRES "expires"
	43	#define KEY_ISSUER "issuer"
	44	#define KEY_ISSUED "issued"
	45
	46	static heap_t shun_heap; /* key: expiry time, data: struct shun_entry* */
	47	static dict_t shun_dict; /* key: target, data: struct shun_entry* */
	48
	49	static int
	50	shun_comparator(const void a, const void b)
	51	{
	52	const struct shun ga=a, gb=b;
	53	return ga->expires - gb->expires;
	54	}
	55
	56	static void
	57	free_shun_from_dict(void *data)
	58	{
	59	struct shun *ent = data;
	60	free(ent->issuer);
	61	free(ent->target);
	62	free(ent->reason);
	63	free(ent);
	64	}
65
66	static void
67	free_shun(struct shun *ent)
68	{
69	dict_remove(shun_dict, ent->target);
70	}
71
72	static int
73	shun_for_p(UNUSED_ARG(void key), void data, void *extra)
74	{
75	struct shun *ge = data;
76	return !irccasecmp(ge->target, extra);
77	}
78
79	static int
80	delete_shun_for_p(UNUSED_ARG(void key), void data, void *extra)
81	{
82	struct shun *ge = data;
83
84	if (!irccasecmp(ge->target, extra)) {
85	free_shun(ge);
86	return 1;
87	} else {
88	return 0;
89	}
90	}
91
92	static void
93	shun_expire(UNUSED_ARG(void *data))
94	{
95	time_t stopped;
96	void *wraa;
97
98	stopped = 0;
99	while (heap_size(shun_heap)) {
100	heap_peek(shun_heap, 0, &wraa);
101	stopped = ((struct shun*)wraa)->expires;
102	if (stopped > now)
103	break;
104	heap_pop(shun_heap);
105	free_shun(wraa);
106	}
107	if (heap_size(shun_heap))
108	timeq_add(stopped, shun_expire, NULL);
109	}
110
111	int
112	shun_remove(const char *target, int announce)
113	{
114	int res = dict_find(shun_dict, target, NULL) ? 1 : 0;
115	if (heap_remove_pred(shun_heap, delete_shun_for_p, (char*)target)) {
116	void *argh;
117	struct shun *new_first;
118	heap_peek(shun_heap, 0, &argh);
119	if (argh) {
120	new_first = argh;
121	timeq_del(0, shun_expire, 0, TIMEQ_IGNORE_WHEN\|TIMEQ_IGNORE_DATA);
122	timeq_add(new_first->expires, shun_expire, 0);
123	}
124	}
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. */
129	announce = 1;
130	#endif
131	if (announce)
132	irc_unshun(target);
133	return res;
134	}
135
136	struct shun *
137	shun_add(const char issuer, const char target, unsigned long duration, const char *reason, time_t issued, int announce)
138	{
139	struct shun *ent;
140	struct shun *prev_first;
141	void *argh;
142
143	heap_peek(shun_heap, 0, &argh);
144	prev_first = argh;
145	ent = dict_find(shun_dict, target, NULL);
146	if (ent) {
147	heap_remove_pred(shun_heap, shun_for_p, (char*)target);
148	if (ent->expires < (time_t)(now + duration))
149	ent->expires = now + duration;
150	} else {
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(shun_dict, ent->target, ent);
158	}
159	heap_insert(shun_heap, ent, ent);
160	if (!prev_first \|\| (ent->expires < prev_first->expires)) {
161	timeq_del(0, shun_expire, 0, TIMEQ_IGNORE_WHEN\|TIMEQ_IGNORE_DATA);
162	timeq_add(ent->expires, shun_expire, 0);
163	}
164	if (announce)
165	irc_shun(NULL, ent);
166	return ent;
167	}
168
169	static char *
170	shun_alternate_target(const char *target)
171	{
172	const char *hostname;
d914d1cb	173
	174	/* If no host part, bail. */
	175	if (!(hostname = strchr(target, '@')))
	176	return NULL;
	177	/* If host part contains wildcards, bail. */
	178	if (hostname[strcspn(hostname, "*?/")])
	179	return NULL;
2f61d1d7	180	/* Get parsed address and canonical name for host. */
	181	#if 0
	182	irc_in_addr_t in; /* move this to the right place */
	183	if (irc_pton(&in, NULL, hostname+1)) {
	184	if (getnameinfo(/TODO/))
	185	return NULL;
	186	} else if (!getaddrinfo(/TODO/)) {
	187	} else return NULL;
	188	#else
	189	return NULL;
	190	#endif
d914d1cb	191	}
	192
	193	struct shun *
	194	shun_find(const char *target)
	195	{
	196	struct shun *res;
	197	dict_iterator_t it;
	198	char *alt_target;
	199
	200	res = dict_find(shun_dict, target, NULL);
	201	if (res)
	202	return res;
	203	/* Stock ircu requires BADCHANs to match exactly. */
	204	if ((target[0] == '#') \|\| (target[0] == '&'))
	205	return NULL;
	206	else if (target[strcspn(target, "*?")]) {
	207	/* Wildcard: do an obnoxiously long search. */
	208	for (it = dict_first(shun_dict); it; it = iter_next(it)) {
	209	res = iter_data(it);
	210	if (match_ircglob(target, res->target))
	211	return res;
	212	}
	213	}
	214	/* See if we can resolve the hostname part of the mask. */
	215	if ((alt_target = shun_alternate_target(target))) {
	216	res = shun_find(alt_target);
	217	free(alt_target);
	218	return res;
	219	}
	220	return NULL;
	221	}
	222
	223	static int
	224	shun_refresh_helper(UNUSED_ARG(void key), void data, void *extra)
	225	{
	226	struct shun *ge = data;
	227	irc_shun(extra, ge);
	228	return 0;
	229	}
	230
	231	void
	232	shun_refresh_server(struct server *srv)
	233	{
	234	heap_remove_pred(shun_heap, shun_refresh_helper, srv);
	235	}
	236
	237	void
	238	shun_refresh_all(void)
	239	{
	240	heap_remove_pred(shun_heap, shun_refresh_helper, 0);
	241	}
	242
	243	unsigned int
	244	shun_count(void)
	245	{
	246	return dict_size(shun_dict);
	247	}
	248
	249	static int
	250	shun_add_record(const char key, void data, UNUSED_ARG(void *extra))
	251	{
	252	struct record_data *rd = data;
	253	const char issuer, reason, *dstr;
	254	time_t issued, expiration;
255
256	if (!(reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING))) {
257	log_module(MAIN_LOG, LOG_ERROR, "Missing reason for shun %s", key);
258	return 0;
259	}
260	if (!(dstr = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING))) {
261	log_module(MAIN_LOG, LOG_ERROR, "Missing expiration for shun %s", key);
262	return 0;
263	}
264	expiration = strtoul(dstr, NULL, 0);
265	if ((dstr = database_get_data(rd->d.object, KEY_ISSUED, RECDB_QSTRING))) {
266	issued = strtoul(dstr, NULL, 0);
267	} else {
268	issued = now;
269	}
270	if (!(issuer = database_get_data(rd->d.object, KEY_ISSUER, RECDB_QSTRING))) {
271	issuer = "<unknown>";
272	}
273	if (expiration > now)
274	shun_add(issuer, key, expiration - now, reason, issued, 0);
275	return 0;
276	}
277
278	static int
279	shun_saxdb_read(struct dict *db)
280	{
281	return dict_foreach(db, shun_add_record, 0) != NULL;
282	}
283
284	static int
285	shun_write_entry(UNUSED_ARG(void key), void data, void *extra)
286	{
287	struct shun *ent = data;
288	struct saxdb_context *ctx = extra;
289
290	saxdb_start_record(ctx, ent->target, 0);
291	saxdb_write_int(ctx, KEY_EXPIRES, ent->expires);
292	saxdb_write_int(ctx, KEY_ISSUED, ent->issued);
293	saxdb_write_string(ctx, KEY_REASON, ent->reason);
294	saxdb_write_string(ctx, KEY_ISSUER, ent->issuer);
295	saxdb_end_record(ctx);
296	return 0;
297	}
298
299	static int
300	shun_saxdb_write(struct saxdb_context *ctx)
301	{
302	heap_remove_pred(shun_heap, shun_write_entry, ctx);
303	return 0;
304	}
305
306	static void
307	shun_db_cleanup(void)
308	{
309	heap_delete(shun_heap);
310	dict_delete(shun_dict);
311	}
312
313	void
314	shun_init(void)
315	{
316	shun_heap = heap_new(shun_comparator);
317	shun_dict = dict_new();
318	dict_set_free_data(shun_dict, free_shun_from_dict);
319	saxdb_register("shun", shun_saxdb_read, shun_saxdb_write);
320	reg_exit_func(shun_db_cleanup);
321	}
322
323	struct shun_discrim *
324	shun_discrim_create(struct userNode user, struct userNode src, unsigned int argc, char *argv[])
325	{
326	unsigned int i;
327	struct shun_discrim *discrim;
328
329	discrim = calloc(1, sizeof(*discrim));
330	discrim->max_issued = now;
331	discrim->limit = 50;
332
333	for (i=0; i<argc; i++) {
334	if (i + 2 > argc) {
335	send_message(user, src, "MSG_MISSING_PARAMS", argv[i]);
336	goto fail;
337	} else if (!irccasecmp(argv[i], "mask") \|\| !irccasecmp(argv[i], "host")) {
338	if (!irccasecmp(argv[++i], "exact"))
339	discrim->target_mask_type = SEXACT;
340	else if (!irccasecmp(argv[i], "subset"))
341	discrim->target_mask_type = SSUBSET;
342	else if (!irccasecmp(argv[i], "superset"))
343	discrim->target_mask_type = SSUPERSET;
344	else
345	discrim->target_mask_type = SSUBSET, i--;
346	if (++i == argc) {
347	send_message(user, src, "MSG_MISSING_PARAMS", argv[i-1]);
348	goto fail;
349	}
350	if (!is_shun(argv[i]) && !IsChannelName(argv[i])) {
351	send_message(user, src, "MSG_INVALID_SHUN", argv[i]);
352	goto fail;
353	}
354	discrim->target_mask = argv[i];
355	discrim->alt_target_mask = shun_alternate_target(discrim->target_mask);
356	} else if (!irccasecmp(argv[i], "limit"))
357	discrim->limit = strtoul(argv[++i], NULL, 0);
358	else if (!irccasecmp(argv[i], "reason"))
359	discrim->reason_mask = argv[++i];
360	else if (!irccasecmp(argv[i], "issuer"))
361	discrim->issuer_mask = argv[++i];
362	else if (!irccasecmp(argv[i], "after"))
363	discrim->min_expire = now + ParseInterval(argv[++i]);
364	else if (!irccasecmp(argv[i], "before"))
365	discrim->max_issued = now - ParseInterval(argv[++i]);
366	else {
367	send_message(user, src, "MSG_INVALID_CRITERIA", argv[i]);
368	goto fail;
369	}
370	}
371	return discrim;
372	fail:
373	free(discrim->alt_target_mask);
374	free(discrim);
375	return NULL;
376	}
377
378	struct shun_search {
379	struct shun_discrim *discrim;
380	shun_search_func func;
381	void *data;
382	unsigned int hits;
383	};
384
385	static int
386	shun_discrim_match(struct shun shun, struct shun_discrim discrim)
387	{
388	if ((discrim->issuer_mask && !match_ircglob(shun->issuer, discrim->issuer_mask))
389	\|\| (discrim->reason_mask && !match_ircglob(shun->reason, discrim->reason_mask))
390	\|\| (discrim->target_mask
391	&& (((discrim->target_mask_type == SSUBSET)
392	&& !match_ircglobs(discrim->target_mask, shun->target)
393	&& (!discrim->alt_target_mask
394	\|\| !match_ircglobs(discrim->alt_target_mask, shun->target)))
395	\|\| ((discrim->target_mask_type == SEXACT)
396	&& irccasecmp(discrim->target_mask, shun->target)
397	&& (!discrim->alt_target_mask
398	\|\| !irccasecmp(discrim->alt_target_mask, shun->target)))
399	\|\| ((discrim->target_mask_type == SSUPERSET)
400	&& !match_ircglobs(shun->target, discrim->target_mask)
401	&& (!discrim->alt_target_mask
402	\|\| !match_ircglobs(discrim->alt_target_mask, shun->target)))))
403	\|\| (discrim->max_issued < shun->issued)
404	\|\| (discrim->min_expire > shun->expires)) {
405	return 0;
406	}
407	return 1;
408	}
409
410	static int
411	shun_search_helper(UNUSED_ARG(void key), void data, void *extra)
412	{
413	struct shun *shun = data;
414	struct shun_search *search = extra;
415
416	if (shun_discrim_match(shun, search->discrim)
417	&& (search->hits++ < search->discrim->limit)) {
418	search->func(shun, search->data);
419	}
420	return 0;
421	}
422
423	unsigned int
424	shun_discrim_search(struct shun_discrim discrim, shun_search_func gsf, void data)
425	{
426	struct shun_search search;
427	search.discrim = discrim;
428	search.func = gsf;
429	search.data = data;
430	search.hits = 0;
431	heap_remove_pred(shun_heap, shun_search_helper, &search);
432	return search.hits;
433	}