[irc/rqf/shadowircd.git] / src / hostmask.c

/*
 *  charybdis: an advanced internet relay chat daemon (ircd).
 *  hostmask.c: Code to efficiently find IP & hostmask based configs.
 *
 *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
 *  Copyright (C) 1996-2002 Hybrid Development Team
 *  Copyright (C) 2002-2005 ircd-ratbox development team
 *  Copyright (C) 2005-2008 charybdis development team
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id: hostmask.c 2757 2006-11-10 22:58:15Z jilles $
 */

#include "stdinc.h"
#include "ircd_defs.h"
#include "s_conf.h"
#include "hostmask.h"
#include "numeric.h"
#include "send.h"
#include "irc_string.h"

#ifdef IPV6
static unsigned long hash_ipv6(struct sockaddr *, int);
#endif
static unsigned long hash_ipv4(struct sockaddr *, int);


/* int parse_netmask(const char *, struct irc_sockaddr_storage *, int *);
 * Input: A hostmask, or an IPV4/6 address.
 * Output: An integer describing whether it is an IPV4, IPV6 address or a
 *         hostmask, an address(if it is an IP mask),
 *         a bitlength(if it is IP mask).
 * Side effects: None
 */
int
parse_netmask(const char *text, struct sockaddr  *naddr, int *nb)
{
	char *ip = LOCAL_COPY(text);
	char *ptr;
	struct irc_sockaddr_storage *addr, xaddr;
	int *b, xb;
	if(nb == NULL)
		b = &xb;
	else
		b = nb;
	
	if(naddr == NULL)
		addr = (struct irc_sockaddr_storage *)&xaddr;
	else
		addr = (struct irc_sockaddr_storage *)naddr;
	
#ifdef IPV6
	if(strchr(ip, ':'))
	{	
		if((ptr = strchr(ip, '/')))
		{
			*ptr = '\0';
			ptr++;
			*b = atoi(ptr);
			if(*b > 128)
				*b = 128;
		} else
			*b = 128;
		if(inetpton_sock(ip, (struct sockaddr *)addr) > 0)
			return HM_IPV6;
		else
			return HM_HOST;
	} else
#endif
	if(strchr(text, '.'))
	{
		if((ptr = strchr(ip, '/')))
		{
			*ptr = '\0';
			ptr++;
			*b = atoi(ptr);
			if(*b > 32)
				*b = 32;
		} else
			*b = 32;
		if(inetpton_sock(ip, (struct sockaddr *)addr) > 0)
			return HM_IPV4;
		else
			return HM_HOST;
	}
	return HM_HOST;
}

/* Hashtable stuff...now external as its used in m_stats.c */
struct AddressRec *atable[ATABLE_SIZE];

void
init_host_hash(void)
{
	memset(&atable, 0, sizeof(atable));
}

/* unsigned long hash_ipv4(struct irc_sockaddr_storage*)
 * Input: An IP address.
 * Output: A hash value of the IP address.
 * Side effects: None
 */
static unsigned long
hash_ipv4(struct sockaddr *saddr, int bits)
{
	struct sockaddr_in *addr = (struct sockaddr_in *) saddr;
	
	if(bits != 0)
	{
		unsigned long av = ntohl(addr->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1);
		return (av ^ (av >> 12) ^ (av >> 24)) & (ATABLE_SIZE - 1);
	}

	return 0;
}

/* unsigned long hash_ipv6(struct irc_sockaddr_storage*)
 * Input: An IP address.
 * Output: A hash value of the IP address.
 * Side effects: None
 */
#ifdef IPV6
static unsigned long
hash_ipv6(struct sockaddr *saddr, int bits)
{
	struct sockaddr_in6 *addr = (struct sockaddr_in6 *) saddr;
	unsigned long v = 0, n;
	for (n = 0; n < 16; n++)
	{
		if(bits >= 8)
		{
			v ^= addr->sin6_addr.s6_addr[n];
			bits -= 8;
		}
		else if(bits)
		{
			v ^= addr->sin6_addr.s6_addr[n] & ~((1 << (8 - bits)) - 1);
			return v & (ATABLE_SIZE - 1);
		}
		else
			return v & (ATABLE_SIZE - 1);
	}
	return v & (ATABLE_SIZE - 1);
}
#endif

/* int hash_text(const char *start)
 * Input: The start of the text to hash.
 * Output: The hash of the string between 1 and (TH_MAX-1)
 * Side-effects: None.
 */
static int
hash_text(const char *start)
{
	const char *p = start;
	unsigned long h = 0;

	while(*p)
	{
		h = (h << 4) - (h + (unsigned char) ToLower(*p++));
	}

	return (h & (ATABLE_SIZE - 1));
}

/* unsigned long get_hash_mask(const char *)
 * Input: The text to hash.
 * Output: The hash of the string right of the first '.' past the last
 *         wildcard in the string.
 * Side-effects: None.
 */
static unsigned long
get_mask_hash(const char *text)
{
	const char *hp = "", *p;

	for (p = text + strlen(text) - 1; p >= text; p--)
		if(*p == '*' || *p == '?')
			return hash_text(hp);
		else if(*p == '.')
			hp = p + 1;
	return hash_text(text);
}

/* struct ConfItem* find_conf_by_address(const char*, struct irc_sockaddr_storage*,
 *         int type, int fam, const char *username)
 * Input: The hostname, the address, the type of mask to find, the address
 *        family, the username.
 * Output: The matching value with the highest precedence.
 * Side-effects: None
 * Note: Setting bit 0 of the type means that the username is ignored.
 */
struct ConfItem *
find_conf_by_address(const char *name, const char *sockhost,
			const char *orighost,
			struct sockaddr *addr, int type, int fam, 
			const char *username)
{
	unsigned long hprecv = 0;
	struct ConfItem *hprec = NULL;
	struct AddressRec *arec;
	int b;

	if(username == NULL)
		username = "";

	if(addr)
	{
		/* Check for IPV6 matches... */
#ifdef IPV6
		if(fam == AF_INET6)
		{

			for (b = 128; b >= 0; b -= 16)
			{
				for (arec = atable[hash_ipv6(addr, b)]; arec; arec = arec->next)
					if(arec->type == (type & ~0x1) &&
					   arec->masktype == HM_IPV6 &&
					   comp_with_mask_sock(addr, (struct sockaddr *)&arec->Mask.ipa.addr,
							       arec->Mask.ipa.bits) && (type & 0x1
											||
											match(arec->
											      username,
											      username))
					   && arec->precedence > hprecv)
					{
						hprecv = arec->precedence;
						hprec = arec->aconf;
					}
			}
		}
		else
#endif
		if(fam == AF_INET)
		{
			for (b = 32; b >= 0; b -= 8)
			{
				for (arec = atable[hash_ipv4(addr, b)]; arec; arec = arec->next)
					if(arec->type == (type & ~0x1) &&
					   arec->masktype == HM_IPV4 &&
					   arec->precedence > hprecv && 
					   comp_with_mask_sock(addr, (struct sockaddr *)&arec->Mask.ipa.addr,
							       arec->Mask.ipa.bits) && 
					   (type & 0x1 || match(arec->username, username)))
					{
						hprecv = arec->precedence;
						hprec = arec->aconf;
					}
			}
		}
	}

	if(orighost != NULL)
	{
		const char *p;

		for (p = orighost; p != NULL;)
		{
			for (arec = atable[hash_text(p)]; arec; arec = arec->next)
				
				if((arec->type == (type & ~0x1)) &&
				   (arec->masktype == HM_HOST) &&
				   arec->precedence > hprecv &&
				   match(arec->Mask.hostname, orighost) &&
				   (type & 0x1 || match(arec->username, username)))
				{
					hprecv = arec->precedence;
					hprec = arec->aconf;
				}
			p = strchr(p, '.');
			if(p != NULL)
				p++;
			else
				break;
		}
		for (arec = atable[0]; arec; arec = arec->next)
		{
			if(arec->type == (type & ~0x1) &&
			   arec->masktype == HM_HOST &&
			   arec->precedence > hprecv && 
			   (match(arec->Mask.hostname, orighost) ||
			    (sockhost && match(arec->Mask.hostname, sockhost))) &&
			   (type & 0x1 || match(arec->username, username)))
			{
				hprecv = arec->precedence;
				hprec = arec->aconf;
			}
		}
	}

	if(name != NULL)
	{
		const char *p;
		/* And yes - we have to check p after strchr and p after increment for
		 * NULL -kre */
		for (p = name; p != NULL;)
		{
			for (arec = atable[hash_text(p)]; arec; arec = arec->next)
				if((arec->type == (type & ~0x1)) &&
				   (arec->masktype == HM_HOST) &&
				   arec->precedence > hprecv &&
				   match(arec->Mask.hostname, name) &&
				   (type & 0x1 || match(arec->username, username)))
				{
					hprecv = arec->precedence;
					hprec = arec->aconf;
				}
			p = strchr(p, '.');
			if(p != NULL)
				p++;
			else
				break;
		}
		for (arec = atable[0]; arec; arec = arec->next)
		{
			if(arec->type == (type & ~0x1) &&
			   arec->masktype == HM_HOST &&
			   arec->precedence > hprecv && 
			   (match(arec->Mask.hostname, name) ||
			    (sockhost && match(arec->Mask.hostname, sockhost))) &&
			   (type & 0x1 || match(arec->username, username)))
			{
				hprecv = arec->precedence;
				hprec = arec->aconf;
			}
		}
	}
	return hprec;
}

/* struct ConfItem* find_address_conf(const char*, const char*,
 * 	                               struct irc_sockaddr_storage*, int);
 * Input: The hostname, username, address, address family.
 * Output: The applicable ConfItem.
 * Side-effects: None
 */
struct ConfItem *
find_address_conf(const char *host, const char *sockhost, const char *user, 
		const char *notildeuser, struct sockaddr *ip, int aftype)
{
	struct ConfItem *iconf, *kconf;
	const char *vuser;

	/* Find the best I-line... If none, return NULL -A1kmm */
	if(!(iconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_CLIENT, aftype, user)))
		return NULL;
	/* Find what their visible username will be.
	 * Note that the username without tilde may contain one char more.
	 * -- jilles */
	vuser = IsNoTilde(iconf) ? notildeuser : user;

	/* If they are exempt from K-lines, return the best I-line. -A1kmm */
	if(IsConfExemptKline(iconf))
		return iconf;

	/* Find the best K-line... -A1kmm */
	kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_KILL, aftype, user);

	/* If they are K-lined, return the K-line */
	if(kconf)
		return kconf;

	/* if theres a spoof, check it against klines.. */
	if(IsConfDoSpoofIp(iconf))
	{
		char *p = strchr(iconf->name, '@');

		/* note, we dont need to pass sockhost here, as its
		 * guaranteed to not match by whats above.. --anfl
		 */
		if(p)
		{
			*p = '\0';
			kconf = find_conf_by_address(p+1, NULL, NULL, ip, CONF_KILL, aftype, iconf->name);
			*p = '@';
		}
		else
			kconf = find_conf_by_address(iconf->name, NULL, NULL, ip, CONF_KILL, aftype, vuser);

		if(kconf)
			return kconf;
	}

	/* if no_tilde, check the username without tilde against klines too
	 * -- jilles */
	if(user != vuser)
	{
		kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_KILL, aftype, vuser);
		if(kconf)
			return kconf;
	}

	/* hunt for a gline */
	if(ConfigFileEntry.glines)
	{
		kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_GLINE, aftype, user);

		if((kconf != NULL) && !IsConfExemptGline(iconf))
			return kconf;
	}

	return iconf;
}

/* struct ConfItem* find_dline(struct irc_sockaddr_storage*, int)
 * Input: An address, an address family.
 * Output: The best matching D-line or exempt line.
 * Side effects: None.
 */
struct ConfItem *
find_dline(struct sockaddr *addr, int aftype)
{
	struct ConfItem *eline;
	eline = find_conf_by_address(NULL, NULL, NULL, addr, CONF_EXEMPTDLINE | 1, aftype, NULL);
	if(eline)
		return eline;
	return find_conf_by_address(NULL, NULL, NULL, addr, CONF_DLINE | 1, aftype, NULL);
}

/* void find_exact_conf_by_address(const char*, int, const char *)
 * Input: 
 * Output: ConfItem if found
 * Side-effects: None
 */
struct ConfItem *
find_exact_conf_by_address(const char *address, int type, const char *username)
{
	int masktype, bits;
	unsigned long hv;
	struct AddressRec *arec;
	struct irc_sockaddr_storage addr;

	if(address == NULL)
		address = "/NOMATCH!/";
	arec = MyMalloc(sizeof(struct AddressRec));
	masktype = parse_netmask(address, (struct sockaddr *)&addr, &bits);
#ifdef IPV6
	if(masktype == HM_IPV6)
	{
		/* We have to do this, since we do not re-hash for every bit -A1kmm. */
		hv = hash_ipv6((struct sockaddr *)&addr, bits - bits % 16);
	}
	else
#endif
	if(masktype == HM_IPV4)
	{
		/* We have to do this, since we do not re-hash for every bit -A1kmm. */
		hv = hash_ipv4((struct sockaddr *)&addr, bits - bits % 8);
	}
	else
	{
		hv = get_mask_hash(address);
	}
	for (arec = atable[hv]; arec; arec = arec->next)
	{
		if (arec->type == type &&
				arec->masktype == masktype &&
				(arec->username == NULL || username == NULL ? arec->username == username : !irccmp(arec->username, username)))
		{
			if (masktype == HM_HOST)
			{
				if (!irccmp(arec->Mask.hostname, address))
					return arec->aconf;
			}
			else
			{
				if (arec->Mask.ipa.bits == bits &&
					comp_with_mask_sock((struct sockaddr *)&arec->Mask.ipa.addr, (struct sockaddr *)&addr, bits))
					return arec->aconf;
			}
		}
	}
	return NULL;
}

/* void add_conf_by_address(const char*, int, const char *,
 *         struct ConfItem *aconf)
 * Input: 
 * Output: None
 * Side-effects: Adds this entry to the hash table.
 */
void
add_conf_by_address(const char *address, int type, const char *username, struct ConfItem *aconf)
{
	static unsigned long prec_value = 0xFFFFFFFF;
	int masktype, bits;
	unsigned long hv;
	struct AddressRec *arec;

	if(address == NULL)
		address = "/NOMATCH!/";
	arec = MyMalloc(sizeof(struct AddressRec));
	masktype = parse_netmask(address, (struct sockaddr *)&arec->Mask.ipa.addr, &bits);
	arec->Mask.ipa.bits = bits;
	arec->masktype = masktype;
#ifdef IPV6
	if(masktype == HM_IPV6)
	{
		/* We have to do this, since we do not re-hash for every bit -A1kmm. */
		bits -= bits % 16;
		arec->next = atable[(hv = hash_ipv6((struct sockaddr *)&arec->Mask.ipa.addr, bits))];
		atable[hv] = arec;
	}
	else
#endif
	if(masktype == HM_IPV4)
	{
		/* We have to do this, since we do not re-hash for every bit -A1kmm. */
		bits -= bits % 8;
		arec->next = atable[(hv = hash_ipv4((struct sockaddr *)&arec->Mask.ipa.addr, bits))];
		atable[hv] = arec;
	}
	else
	{
		arec->Mask.hostname = address;
		arec->next = atable[(hv = get_mask_hash(address))];
		atable[hv] = arec;
	}
	arec->username = username;
	arec->aconf = aconf;
	arec->precedence = prec_value--;
	arec->type = type;
}

/* void delete_one_address(const char*, struct ConfItem*)
 * Input: An address string, the associated ConfItem.
 * Output: None
 * Side effects: Deletes an address record. Frees the ConfItem if there
 *               is nothing referencing it, sets it as illegal otherwise.
 */
void
delete_one_address_conf(const char *address, struct ConfItem *aconf)
{
	int masktype, bits;
	unsigned long hv;
	struct AddressRec *arec, *arecl = NULL;
	struct irc_sockaddr_storage addr;
	masktype = parse_netmask(address, (struct sockaddr *)&addr, &bits);
#ifdef IPV6
	if(masktype == HM_IPV6)
	{
		/* We have to do this, since we do not re-hash for every bit -A1kmm. */
		bits -= bits % 16;
		hv = hash_ipv6((struct sockaddr *)&addr, bits);
	}
	else
#endif
	if(masktype == HM_IPV4)
	{
		/* We have to do this, since we do not re-hash for every bit -A1kmm. */
		bits -= bits % 8;
		hv = hash_ipv4((struct sockaddr *)&addr, bits);
	}
	else
		hv = get_mask_hash(address);
	for (arec = atable[hv]; arec; arec = arec->next)
	{
		if(arec->aconf == aconf)
		{
			if(arecl)
				arecl->next = arec->next;
			else
				atable[hv] = arec->next;
			aconf->status |= CONF_ILLEGAL;
			if(!aconf->clients)
				free_conf(aconf);
			rb_free(arec);
			return;
		}
		arecl = arec;
	}
}

/* void clear_out_address_conf(void)
 * Input: None
 * Output: None
 * Side effects: Clears out all address records in the hash table,
 *               frees them, and frees the ConfItems if nothing references
 *               them, otherwise sets them as illegal.
 */
void
clear_out_address_conf(void)
{
	int i;
	struct AddressRec **store_next;
	struct AddressRec *arec, *arecn;

	for (i = 0; i < ATABLE_SIZE; i++)
	{
		store_next = &atable[i];
		for (arec = atable[i]; arec; arec = arecn)
		{
			arecn = arec->next;
			/* We keep the temporary K-lines and destroy the
			 * permanent ones, just to be confusing :) -A1kmm */
			if(arec->aconf->flags & CONF_FLAGS_TEMPORARY ||
			   (arec->type != CONF_CLIENT && arec->type != CONF_EXEMPTDLINE))
			{
				*store_next = arec;
				store_next = &arec->next;
			}
			else
			{
				arec->aconf->status |= CONF_ILLEGAL;
				if(!arec->aconf->clients)
					free_conf(arec->aconf);
				rb_free(arec);
			}
		}
		*store_next = NULL;
	}
}

void
clear_out_address_conf_bans(void)
{
	int i;
	struct AddressRec **store_next;
	struct AddressRec *arec, *arecn;

	for (i = 0; i < ATABLE_SIZE; i++)
	{
		store_next = &atable[i];
		for (arec = atable[i]; arec; arec = arecn)
		{
			arecn = arec->next;
			/* We keep the temporary K-lines and destroy the
			 * permanent ones, just to be confusing :) -A1kmm */
			if(arec->aconf->flags & CONF_FLAGS_TEMPORARY ||
			   (arec->type == CONF_CLIENT || arec->type == CONF_EXEMPTDLINE))
			{
				*store_next = arec;
				store_next = &arec->next;
			}
			else
			{
				arec->aconf->status |= CONF_ILLEGAL;
				if(!arec->aconf->clients)
					free_conf(arec->aconf);
				rb_free(arec);
			}
		}
		*store_next = NULL;
	}
}


/*
 * show_iline_prefix()
 *
 * inputs       - pointer to struct Client requesting output
 *              - pointer to struct ConfItem 
 *              - name to which iline prefix will be prefixed to
 * output       - pointer to static string with prefixes listed in ascii form
 * side effects - NONE
 */
char *
show_iline_prefix(struct Client *sptr, struct ConfItem *aconf, char *name)
{
	static char prefix_of_host[USERLEN + 15];
	char *prefix_ptr;

	prefix_ptr = prefix_of_host;
	if(IsNoTilde(aconf))
		*prefix_ptr++ = '-';
	if(IsNeedIdentd(aconf))
		*prefix_ptr++ = '+';
	if(IsConfDoSpoofIp(aconf))
		*prefix_ptr++ = '=';
	if(IsOper(sptr) && IsConfExemptFlood(aconf))
		*prefix_ptr++ = '|';
	if(IsOper(sptr) && IsConfExemptGline(aconf) && !IsConfExemptKline(aconf))
		*prefix_ptr++ = '_';
	if(IsOper(sptr) && IsConfExemptDNSBL(aconf) && !IsConfExemptKline(aconf))
		*prefix_ptr++ = '$';
	if(IsOper(sptr) && IsConfExemptKline(aconf))
		*prefix_ptr++ = '^';
	if(IsOper(sptr) && IsConfExemptLimits(aconf))
		*prefix_ptr++ = '>';
	*prefix_ptr = '\0';
	strncpy(prefix_ptr, name, USERLEN);
	return (prefix_of_host);
}

/* report_auth()
 *
 * Inputs: pointer to client to report to
 * Output: None
 * Side effects: Reports configured auth{} blocks to client_p
 */
void
report_auth(struct Client *client_p)
{
	char *name, *host, *pass, *user, *classname;
	struct AddressRec *arec;
	struct ConfItem *aconf;
	int i, port;

	for (i = 0; i < ATABLE_SIZE; i++)
		for (arec = atable[i]; arec; arec = arec->next)
			if(arec->type == CONF_CLIENT)
			{
				aconf = arec->aconf;

				if(!IsOper(client_p) && IsConfDoSpoofIp(aconf))
					continue;

				get_printable_conf(aconf, &name, &host, &pass, &user, &port,
						   &classname);

				sendto_one_numeric(client_p, RPL_STATSILINE, 
						   form_str(RPL_STATSILINE),
						   name, show_iline_prefix(client_p, aconf, user),
						   show_ip_conf(aconf, client_p) ? host : "255.255.255.255",
						   port, classname);
			}
}

/* report_Klines()
 * 
 * inputs       - Client to report to, mask 
 * outputs      -
 * side effects - Reports configured K-lines to client_p.
 */
void
report_Klines(struct Client *source_p)
{
	char *host, *pass, *user, *oper_reason;
	struct AddressRec *arec;
	struct ConfItem *aconf = NULL;
	int i;

	for (i = 0; i < ATABLE_SIZE; i++)
	{
		for (arec = atable[i]; arec; arec = arec->next)
		{
			if(arec->type == CONF_KILL)
			{
				aconf = arec->aconf;

				/* its a tempkline, theyre reported elsewhere */
				if(aconf->flags & CONF_FLAGS_TEMPORARY)
					continue;

				get_printable_kline(source_p, aconf, &host, &pass, &user, &oper_reason);
				sendto_one_numeric(source_p, RPL_STATSKLINE,
						   form_str(RPL_STATSKLINE),
						   'K', host, user, pass,
						   oper_reason ? "|" : "",
						   oper_reason ? oper_reason : "");
			}
		}
	}
}
Commit	Line	Data
212380e3	1	/*
	2	* charybdis: an advanced internet relay chat daemon (ircd).
	3	* hostmask.c: Code to efficiently find IP & hostmask based configs.
	4	*
	5	* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
	6	* Copyright (C) 1996-2002 Hybrid Development Team
	7	* Copyright (C) 2002-2005 ircd-ratbox development team
eb6e811f	8	* Copyright (C) 2005-2008 charybdis development team
212380e3	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	23	* USA
	24	*
	25	* $Id: hostmask.c 2757 2006-11-10 22:58:15Z jilles $
	26	*/
	27
	28	#include "stdinc.h"
212380e3	29	#include "ircd_defs.h"
	30	#include "s_conf.h"
	31	#include "hostmask.h"
	32	#include "numeric.h"
	33	#include "send.h"
	34	#include "irc_string.h"
	35
	36	#ifdef IPV6
	37	static unsigned long hash_ipv6(struct sockaddr *, int);
	38	#endif
	39	static unsigned long hash_ipv4(struct sockaddr *, int);
	40
	41
	42	/* int parse_netmask(const char , struct irc_sockaddr_storage , int *);
	43	* Input: A hostmask, or an IPV4/6 address.
	44	* Output: An integer describing whether it is an IPV4, IPV6 address or a
	45	* hostmask, an address(if it is an IP mask),
	46	* a bitlength(if it is IP mask).
	47	* Side effects: None
	48	*/
	49	int
	50	parse_netmask(const char text, struct sockaddr naddr, int *nb)
	51	{
	52	char *ip = LOCAL_COPY(text);
	53	char *ptr;
	54	struct irc_sockaddr_storage *addr, xaddr;
	55	int *b, xb;
	56	if(nb == NULL)
	57	b = &xb;
	58	else
	59	b = nb;
	60
	61	if(naddr == NULL)
	62	addr = (struct irc_sockaddr_storage *)&xaddr;
	63	else
	64	addr = (struct irc_sockaddr_storage *)naddr;
	65
	66	#ifdef IPV6
	67	if(strchr(ip, ':'))
	68	{
	69	if((ptr = strchr(ip, '/')))
	70	{
	71	*ptr = '\0';
	72	ptr++;
	73	*b = atoi(ptr);
	74	if(*b > 128)
	75	*b = 128;
	76	} else
	77	*b = 128;
	78	if(inetpton_sock(ip, (struct sockaddr *)addr) > 0)
	79	return HM_IPV6;
	80	else
	81	return HM_HOST;
	82	} else
	83	#endif
	84	if(strchr(text, '.'))
	85	{
	86	if((ptr = strchr(ip, '/')))
	87	{
	88	*ptr = '\0';
	89	ptr++;
	90	*b = atoi(ptr);
	91	if(*b > 32)
	92	*b = 32;
93	} else
94	*b = 32;
95	if(inetpton_sock(ip, (struct sockaddr *)addr) > 0)
96	return HM_IPV4;
97	else
98	return HM_HOST;
99	}
100	return HM_HOST;
101	}
102
103	/* Hashtable stuff...now external as its used in m_stats.c */
104	struct AddressRec *atable[ATABLE_SIZE];
105
106	void
107	init_host_hash(void)
108	{
109	memset(&atable, 0, sizeof(atable));
110	}
111
112	/* unsigned long hash_ipv4(struct irc_sockaddr_storage*)
113	* Input: An IP address.
114	* Output: A hash value of the IP address.
115	* Side effects: None
116	*/
117	static unsigned long
118	hash_ipv4(struct sockaddr *saddr, int bits)
119	{
120	struct sockaddr_in addr = (struct sockaddr_in ) saddr;
121
122	if(bits != 0)
123	{
124	unsigned long av = ntohl(addr->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1);
125	return (av ^ (av >> 12) ^ (av >> 24)) & (ATABLE_SIZE - 1);
126	}
127
128	return 0;
129	}
130
131	/* unsigned long hash_ipv6(struct irc_sockaddr_storage*)
132	* Input: An IP address.
133	* Output: A hash value of the IP address.
134	* Side effects: None
135	*/
136	#ifdef IPV6
137	static unsigned long
138	hash_ipv6(struct sockaddr *saddr, int bits)
139	{
140	struct sockaddr_in6 addr = (struct sockaddr_in6 ) saddr;
141	unsigned long v = 0, n;
142	for (n = 0; n < 16; n++)
143	{
144	if(bits >= 8)
145	{
146	v ^= addr->sin6_addr.s6_addr[n];
147	bits -= 8;
148	}
149	else if(bits)
150	{
151	v ^= addr->sin6_addr.s6_addr[n] & ~((1 << (8 - bits)) - 1);
152	return v & (ATABLE_SIZE - 1);
153	}
154	else
155	return v & (ATABLE_SIZE - 1);
156	}
157	return v & (ATABLE_SIZE - 1);
158	}
159	#endif
160
161	/* int hash_text(const char *start)
162	* Input: The start of the text to hash.
163	* Output: The hash of the string between 1 and (TH_MAX-1)
164	* Side-effects: None.
165	*/
166	static int
167	hash_text(const char *start)
168	{
169	const char *p = start;
170	unsigned long h = 0;
171
172	while(*p)
173	{
174	h = (h << 4) - (h + (unsigned char) ToLower(*p++));
175	}
176
177	return (h & (ATABLE_SIZE - 1));
178	}
179
180	/* unsigned long get_hash_mask(const char *)
181	* Input: The text to hash.
182	* Output: The hash of the string right of the first '.' past the last
183	* wildcard in the string.
184	* Side-effects: None.
185	*/
186	static unsigned long
187	get_mask_hash(const char *text)
188	{
189	const char hp = "", p;
190
191	for (p = text + strlen(text) - 1; p >= text; p--)
192	if(p == '' \|\| *p == '?')
193	return hash_text(hp);
194	else if(*p == '.')
195	hp = p + 1;
196	return hash_text(text);
197	}
198
199	/* struct ConfItem* find_conf_by_address(const char, struct irc_sockaddr_storage,
200	* int type, int fam, const char *username)
201	* Input: The hostname, the address, the type of mask to find, the address
202	* family, the username.
203	* Output: The matching value with the highest precedence.
204	* Side-effects: None
205	* Note: Setting bit 0 of the type means that the username is ignored.
206	*/
207	struct ConfItem *
208	find_conf_by_address(const char name, const char sockhost,
209	const char *orighost,
210	struct sockaddr *addr, int type, int fam,
211	const char *username)
212	{
213	unsigned long hprecv = 0;
214	struct ConfItem *hprec = NULL;
215	struct AddressRec *arec;
216	int b;
217
218	if(username == NULL)
219	username = "";
220
221	if(addr)
222	{
223	/* Check for IPV6 matches... */
224	#ifdef IPV6
225	if(fam == AF_INET6)
226	{
227
228	for (b = 128; b >= 0; b -= 16)
229	{
230	for (arec = atable[hash_ipv6(addr, b)]; arec; arec = arec->next)
231	if(arec->type == (type & ~0x1) &&
232	arec->masktype == HM_IPV6 &&
233	comp_with_mask_sock(addr, (struct sockaddr *)&arec->Mask.ipa.addr,
234	arec->Mask.ipa.bits) && (type & 0x1
235	\|\|
236	match(arec->
237	username,
238	username))
239	&& arec->precedence > hprecv)
240	{
241	hprecv = arec->precedence;
242	hprec = arec->aconf;
243	}
244	}
245	}
246	else
247	#endif
248	if(fam == AF_INET)
249	{
250	for (b = 32; b >= 0; b -= 8)
251	{
252	for (arec = atable[hash_ipv4(addr, b)]; arec; arec = arec->next)
253	if(arec->type == (type & ~0x1) &&
254	arec->masktype == HM_IPV4 &&
255	arec->precedence > hprecv &&
256	comp_with_mask_sock(addr, (struct sockaddr *)&arec->Mask.ipa.addr,
257	arec->Mask.ipa.bits) &&
258	(type & 0x1 \|\| match(arec->username, username)))
259	{
260	hprecv = arec->precedence;
261	hprec = arec->aconf;
262	}
263	}
264	}
265	}
266
267	if(orighost != NULL)
268	{
269	const char *p;
270
271	for (p = orighost; p != NULL;)
272	{
273	for (arec = atable[hash_text(p)]; arec; arec = arec->next)
274
275	if((arec->type == (type & ~0x1)) &&
276	(arec->masktype == HM_HOST) &&
277	arec->precedence > hprecv &&
278	match(arec->Mask.hostname, orighost) &&
279	(type & 0x1 \|\| match(arec->username, username)))
280	{
281	hprecv = arec->precedence;
282	hprec = arec->aconf;
283	}
284	p = strchr(p, '.');
285	if(p != NULL)
286	p++;
287	else
288	break;
289	}
290	for (arec = atable[0]; arec; arec = arec->next)
291	{
292	if(arec->type == (type & ~0x1) &&
293	arec->masktype == HM_HOST &&
294	arec->precedence > hprecv &&
295	(match(arec->Mask.hostname, orighost) \|\|
296	(sockhost && match(arec->Mask.hostname, sockhost))) &&
297	(type & 0x1 \|\| match(arec->username, username)))
298	{
299	hprecv = arec->precedence;
300	hprec = arec->aconf;
301	}
302	}
303	}
304
305	if(name != NULL)
306	{
307	const char *p;
308	/* And yes - we have to check p after strchr and p after increment for
309	* NULL -kre */
310	for (p = name; p != NULL;)
311	{
312	for (arec = atable[hash_text(p)]; arec; arec = arec->next)
313	if((arec->type == (type & ~0x1)) &&
314	(arec->masktype == HM_HOST) &&
315	arec->precedence > hprecv &&
316	match(arec->Mask.hostname, name) &&
317	(type & 0x1 \|\| match(arec->username, username)))
318	{
319	hprecv = arec->precedence;
320	hprec = arec->aconf;
321	}
322	p = strchr(p, '.');
323	if(p != NULL)
324	p++;
325	else
326	break;
327	}
328	for (arec = atable[0]; arec; arec = arec->next)
329	{
330	if(arec->type == (type & ~0x1) &&
331	arec->masktype == HM_HOST &&
332	arec->precedence > hprecv &&
333	(match(arec->Mask.hostname, name) \|\|
334	(sockhost && match(arec->Mask.hostname, sockhost))) &&
335	(type & 0x1 \|\| match(arec->username, username)))
336	{
337	hprecv = arec->precedence;
338	hprec = arec->aconf;
339	}
340	}
341	}
342	return hprec;
343	}
344
345	/* struct ConfItem* find_address_conf(const char, const char,
346	* struct irc_sockaddr_storage*, int);
347	* Input: The hostname, username, address, address family.
348	* Output: The applicable ConfItem.
349	* Side-effects: None
350	*/
351	struct ConfItem *
352	find_address_conf(const char host, const char sockhost, const char *user,
353	const char notildeuser, struct sockaddr ip, int aftype)
354	{
355	struct ConfItem iconf, kconf;
356	const char *vuser;
357
358	/* Find the best I-line... If none, return NULL -A1kmm */
359	if(!(iconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_CLIENT, aftype, user)))
360	return NULL;
361	/* Find what their visible username will be.
362	* Note that the username without tilde may contain one char more.
363	* -- jilles */
364	vuser = IsNoTilde(iconf) ? notildeuser : user;
365
366	/* If they are exempt from K-lines, return the best I-line. -A1kmm */
367	if(IsConfExemptKline(iconf))
368	return iconf;
369
370	/* Find the best K-line... -A1kmm */
371	kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_KILL, aftype, user);
372
373	/* If they are K-lined, return the K-line */
374	if(kconf)
375	return kconf;
376
377	/* if theres a spoof, check it against klines.. */
378	if(IsConfDoSpoofIp(iconf))
379	{
380	char *p = strchr(iconf->name, '@');
381
382	/* note, we dont need to pass sockhost here, as its
383	* guaranteed to not match by whats above.. --anfl
384	*/
385	if(p)
386	{
387	*p = '\0';
388	kconf = find_conf_by_address(p+1, NULL, NULL, ip, CONF_KILL, aftype, iconf->name);
389	*p = '@';
390	}
391	else
392	kconf = find_conf_by_address(iconf->name, NULL, NULL, ip, CONF_KILL, aftype, vuser);
393
394	if(kconf)
395	return kconf;
396	}
397
398	/* if no_tilde, check the username without tilde against klines too
399	* -- jilles */
400	if(user != vuser)
401	{
402	kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_KILL, aftype, vuser);
403	if(kconf)
404	return kconf;
405	}
406
407	/* hunt for a gline */
408	if(ConfigFileEntry.glines)
409	{
410	kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_GLINE, aftype, user);
411
412	if((kconf != NULL) && !IsConfExemptGline(iconf))
413	return kconf;
414	}
415
416	return iconf;
417	}
418
419	/* struct ConfItem* find_dline(struct irc_sockaddr_storage*, int)
420	* Input: An address, an address family.
421	* Output: The best matching D-line or exempt line.
422	* Side effects: None.
423	*/
424	struct ConfItem *
425	find_dline(struct sockaddr *addr, int aftype)
426	{
427	struct ConfItem *eline;
428	eline = find_conf_by_address(NULL, NULL, NULL, addr, CONF_EXEMPTDLINE \| 1, aftype, NULL);
429	if(eline)
430	return eline;
431	return find_conf_by_address(NULL, NULL, NULL, addr, CONF_DLINE \| 1, aftype, NULL);
432	}
433
6f3a09ff	434	/* void find_exact_conf_by_address(const char, int, const char )
4e0f14a0 JT	435	* Input:
	436	* Output: ConfItem if found
	437	* Side-effects: None
	438	*/
	439	struct ConfItem *
	440	find_exact_conf_by_address(const char address, int type, const char username)
	441	{
	442	int masktype, bits;
	443	unsigned long hv;
	444	struct AddressRec *arec;
	445	struct irc_sockaddr_storage addr;
	446
	447	if(address == NULL)
	448	address = "/NOMATCH!/";
	449	arec = MyMalloc(sizeof(struct AddressRec));
	450	masktype = parse_netmask(address, (struct sockaddr *)&addr, &bits);
	451	#ifdef IPV6
	452	if(masktype == HM_IPV6)
	453	{
	454	/* We have to do this, since we do not re-hash for every bit -A1kmm. */
	455	hv = hash_ipv6((struct sockaddr *)&addr, bits - bits % 16);
	456	}
	457	else
	458	#endif
	459	if(masktype == HM_IPV4)
	460	{
	461	/* We have to do this, since we do not re-hash for every bit -A1kmm. */
	462	hv = hash_ipv4((struct sockaddr *)&addr, bits - bits % 8);
	463	}
	464	else
	465	{
	466	hv = get_mask_hash(address);
	467	}
	468	for (arec = atable[hv]; arec; arec = arec->next)
	469	{
	470	if (arec->type == type &&
	471	arec->masktype == masktype &&
6f3a09ff	472	(arec->username == NULL \|\| username == NULL ? arec->username == username : !irccmp(arec->username, username)))
4e0f14a0 JT	473	{
	474	if (masktype == HM_HOST)
	475	{
	476	if (!irccmp(arec->Mask.hostname, address))
	477	return arec->aconf;
	478	}
	479	else
	480	{
	481	if (arec->Mask.ipa.bits == bits &&
	482	comp_with_mask_sock((struct sockaddr )&arec->Mask.ipa.addr, (struct sockaddr )&addr, bits))
	483	return arec->aconf;
	484	}
	485	}
	486	}
	487	return NULL;
	488	}
	489
212380e3	490	/* void add_conf_by_address(const char, int, const char ,
	491	* struct ConfItem *aconf)
	492	* Input:
	493	* Output: None
	494	* Side-effects: Adds this entry to the hash table.
	495	*/
	496	void
	497	add_conf_by_address(const char address, int type, const char username, struct ConfItem *aconf)
	498	{
	499	static unsigned long prec_value = 0xFFFFFFFF;
	500	int masktype, bits;
	501	unsigned long hv;
	502	struct AddressRec *arec;
	503
	504	if(address == NULL)
	505	address = "/NOMATCH!/";
	506	arec = MyMalloc(sizeof(struct AddressRec));
	507	masktype = parse_netmask(address, (struct sockaddr *)&arec->Mask.ipa.addr, &bits);
	508	arec->Mask.ipa.bits = bits;
	509	arec->masktype = masktype;
	510	#ifdef IPV6
	511	if(masktype == HM_IPV6)
	512	{
	513	/* We have to do this, since we do not re-hash for every bit -A1kmm. */
	514	bits -= bits % 16;
	515	arec->next = atable[(hv = hash_ipv6((struct sockaddr *)&arec->Mask.ipa.addr, bits))];
	516	atable[hv] = arec;
	517	}
	518	else
	519	#endif
	520	if(masktype == HM_IPV4)
	521	{
	522	/* We have to do this, since we do not re-hash for every bit -A1kmm. */
	523	bits -= bits % 8;
	524	arec->next = atable[(hv = hash_ipv4((struct sockaddr *)&arec->Mask.ipa.addr, bits))];
	525	atable[hv] = arec;
	526	}
	527	else
	528	{
	529	arec->Mask.hostname = address;
	530	arec->next = atable[(hv = get_mask_hash(address))];
	531	atable[hv] = arec;
	532	}
	533	arec->username = username;
	534	arec->aconf = aconf;
	535	arec->precedence = prec_value--;
	536	arec->type = type;
	537	}
	538
	539	/* void delete_one_address(const char, struct ConfItem)
	540	* Input: An address string, the associated ConfItem.
	541	* Output: None
	542	* Side effects: Deletes an address record. Frees the ConfItem if there
	543	* is nothing referencing it, sets it as illegal otherwise.
	544	*/
	545	void
	546	delete_one_address_conf(const char address, struct ConfItem aconf)
	547	{
	548	int masktype, bits;
	549	unsigned long hv;
	550	struct AddressRec arec, arecl = NULL;
	551	struct irc_sockaddr_storage addr;
	552	masktype = parse_netmask(address, (struct sockaddr *)&addr, &bits);
	553	#ifdef IPV6
554	if(masktype == HM_IPV6)
555	{
556	/* We have to do this, since we do not re-hash for every bit -A1kmm. */
557	bits -= bits % 16;
558	hv = hash_ipv6((struct sockaddr *)&addr, bits);
559	}
560	else
561	#endif
562	if(masktype == HM_IPV4)
563	{
564	/* We have to do this, since we do not re-hash for every bit -A1kmm. */
565	bits -= bits % 8;
566	hv = hash_ipv4((struct sockaddr *)&addr, bits);
567	}
568	else
569	hv = get_mask_hash(address);
570	for (arec = atable[hv]; arec; arec = arec->next)
571	{
572	if(arec->aconf == aconf)
573	{
574	if(arecl)
575	arecl->next = arec->next;
576	else
577	atable[hv] = arec->next;
578	aconf->status \|= CONF_ILLEGAL;
579	if(!aconf->clients)
580	free_conf(aconf);
90a3c35b	581	rb_free(arec);
212380e3	582	return;
	583	}
	584	arecl = arec;
	585	}
	586	}
	587
	588	/* void clear_out_address_conf(void)
	589	* Input: None
	590	* Output: None
	591	* Side effects: Clears out all address records in the hash table,
	592	* frees them, and frees the ConfItems if nothing references
	593	* them, otherwise sets them as illegal.
	594	*/
	595	void
	596	clear_out_address_conf(void)
	597	{
	598	int i;
	599	struct AddressRec **store_next;
	600	struct AddressRec arec, arecn;
	601
	602	for (i = 0; i < ATABLE_SIZE; i++)
	603	{
	604	store_next = &atable[i];
	605	for (arec = atable[i]; arec; arec = arecn)
	606	{
	607	arecn = arec->next;
	608	/* We keep the temporary K-lines and destroy the
	609	* permanent ones, just to be confusing :) -A1kmm */
	610	if(arec->aconf->flags & CONF_FLAGS_TEMPORARY \|\|
	611	(arec->type != CONF_CLIENT && arec->type != CONF_EXEMPTDLINE))
	612	{
	613	*store_next = arec;
	614	store_next = &arec->next;
	615	}
	616	else
	617	{
	618	arec->aconf->status \|= CONF_ILLEGAL;
	619	if(!arec->aconf->clients)
	620	free_conf(arec->aconf);
90a3c35b	621	rb_free(arec);
212380e3	622	}
	623	}
	624	*store_next = NULL;
	625	}
	626	}
	627
	628	void
	629	clear_out_address_conf_bans(void)
	630	{
	631	int i;
	632	struct AddressRec **store_next;
	633	struct AddressRec arec, arecn;
	634
	635	for (i = 0; i < ATABLE_SIZE; i++)
	636	{
	637	store_next = &atable[i];
	638	for (arec = atable[i]; arec; arec = arecn)
	639	{
	640	arecn = arec->next;
	641	/* We keep the temporary K-lines and destroy the
	642	* permanent ones, just to be confusing :) -A1kmm */
	643	if(arec->aconf->flags & CONF_FLAGS_TEMPORARY \|\|
	644	(arec->type == CONF_CLIENT \|\| arec->type == CONF_EXEMPTDLINE))
	645	{
	646	*store_next = arec;
	647	store_next = &arec->next;
	648	}
	649	else
	650	{
	651	arec->aconf->status \|= CONF_ILLEGAL;
	652	if(!arec->aconf->clients)
	653	free_conf(arec->aconf);
90a3c35b	654	rb_free(arec);
212380e3	655	}
	656	}
	657	*store_next = NULL;
	658	}
	659	}
	660
	661
	662	/*
	663	* show_iline_prefix()
	664	*
	665	* inputs - pointer to struct Client requesting output
	666	* - pointer to struct ConfItem
	667	* - name to which iline prefix will be prefixed to
	668	* output - pointer to static string with prefixes listed in ascii form
	669	* side effects - NONE
	670	*/
	671	char *
	672	show_iline_prefix(struct Client sptr, struct ConfItem aconf, char *name)
	673	{
	674	static char prefix_of_host[USERLEN + 15];
	675	char *prefix_ptr;
	676
	677	prefix_ptr = prefix_of_host;
	678	if(IsNoTilde(aconf))
	679	*prefix_ptr++ = '-';
212380e3	680	if(IsNeedIdentd(aconf))
212380e3	681	*prefix_ptr++ = '+';
212380e3	682	if(IsConfDoSpoofIp(aconf))
212380e3	683	*prefix_ptr++ = '=';
bd03481b JT	684	if(IsOper(sptr) && IsConfExemptFlood(aconf))
	685	*prefix_ptr++ = '\|';
	686	if(IsOper(sptr) && IsConfExemptGline(aconf) && !IsConfExemptKline(aconf))
	687	*prefix_ptr++ = '_';
	688	if(IsOper(sptr) && IsConfExemptDNSBL(aconf) && !IsConfExemptKline(aconf))
	689	*prefix_ptr++ = '$';
331c47e0	690	if(IsOper(sptr) && IsConfExemptKline(aconf))
212380e3	691	*prefix_ptr++ = '^';
331c47e0	692	if(IsOper(sptr) && IsConfExemptLimits(aconf))
212380e3	693	*prefix_ptr++ = '>';
212380e3	694	*prefix_ptr = '\0';
	695	strncpy(prefix_ptr, name, USERLEN);
	696	return (prefix_of_host);
	697	}
	698
	699	/* report_auth()
	700	*
	701	* Inputs: pointer to client to report to
	702	* Output: None
	703	* Side effects: Reports configured auth{} blocks to client_p
	704	*/
	705	void
	706	report_auth(struct Client *client_p)
	707	{
	708	char name, host, pass, user, *classname;
	709	struct AddressRec *arec;
	710	struct ConfItem *aconf;
	711	int i, port;
	712
	713	for (i = 0; i < ATABLE_SIZE; i++)
	714	for (arec = atable[i]; arec; arec = arec->next)
	715	if(arec->type == CONF_CLIENT)
	716	{
	717	aconf = arec->aconf;
	718
331c47e0	719	if(!IsOper(client_p) && IsConfDoSpoofIp(aconf))
212380e3	720	continue;
	721
	722	get_printable_conf(aconf, &name, &host, &pass, &user, &port,
	723	&classname);
	724
	725	sendto_one_numeric(client_p, RPL_STATSILINE,
	726	form_str(RPL_STATSILINE),
	727	name, show_iline_prefix(client_p, aconf, user),
	728	show_ip_conf(aconf, client_p) ? host : "255.255.255.255",
	729	port, classname);
	730	}
	731	}
	732
	733	/* report_Klines()
	734	*
	735	* inputs - Client to report to, mask
	736	* outputs -
	737	* side effects - Reports configured K-lines to client_p.
	738	*/
	739	void
	740	report_Klines(struct Client *source_p)
	741	{
	742	char host, pass, user, oper_reason;
	743	struct AddressRec *arec;
	744	struct ConfItem *aconf = NULL;
	745	int i;
	746
	747	for (i = 0; i < ATABLE_SIZE; i++)
	748	{
	749	for (arec = atable[i]; arec; arec = arec->next)
	750	{
	751	if(arec->type == CONF_KILL)
	752	{
	753	aconf = arec->aconf;
	754
	755	/* its a tempkline, theyre reported elsewhere */
	756	if(aconf->flags & CONF_FLAGS_TEMPORARY)
	757	continue;
	758
	759	get_printable_kline(source_p, aconf, &host, &pass, &user, &oper_reason);
	760	sendto_one_numeric(source_p, RPL_STATSKLINE,
	761	form_str(RPL_STATSKLINE),
	762	'K', host, user, pass,
	763	oper_reason ? "\|" : "",
	764	oper_reason ? oper_reason : "");
	765	}
	766	}
	767	}
	768	}