ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/hostmask.c

Comparing:
ircd-hybrid-8/src/hostmask.c (file contents), Revision 1376 by michael, Sun Apr 29 17:08:42 2012 UTC vs.
ircd-hybrid/trunk/src/hostmask.c (file contents), Revision 3504 by michael, Sat May 10 19:51:29 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  hostmask.c: Code to efficiently find IP & hostmask based configs.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2005 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 2001-2014 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
20	<	*
21	<	*  $Id$
20	>	*/
21	>
22	>	/*! \file hostmask.c
23	>	* \brief Code to efficiently find IP & hostmask based configs.
24	>	* \version $Id$
25		*/
26
27		#include "stdinc.h"
#	Line 51 | Line 53
53		* Side effects: None
54		* Comments: Called from parse_netmask
55		*/
56	<	/* Fixed so ::/0 (any IPv6 address) is valid
56	>	/* Fixed so ::/0 (any IPv6 address) is valid
57		Also a bug in DigitParse above.
58		-Gozem 2002-07-19 gozem@linux.nu
59		*/
#	Line 59 | Line 61
61		static int
62		try_parse_v6_netmask(const char *text, struct irc_ssaddr *addr, int *b)
63		{
62	–	const char *p;
64		char c;
65		int d[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
66		int dp = 0;
#	Line 70 | Line 71 | try_parse_v6_netmask(const char *text, s
71		short dc[8];
72		struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
73
74	<	for (p = text; (c = *p); p++)
74	>	for (const char *p = text; (c = *p); ++p)
75	>	{
76		if (IsXDigit(c))
77		{
78		if (nyble == 0)
#	Line 108 | Line 110 | try_parse_v6_netmask(const char *text, s
110		char *after;
111
112		d[dp] = d[dp] >> 4 * nyble;
113	<	dp++;
113	>	++dp;
114		bits = strtoul(p + 1, &after, 10);
115
116		if (bits < 0 || *after)
#	Line 119 | Line 121 | try_parse_v6_netmask(const char *text, s
121		}
122		else
123		return HM_HOST;
124	+	}
125
126		d[dp] = d[dp] >> 4 * nyble;
127
128		if (c == 0)
129	<	dp++;
129	>	++dp;
130		if (finsert < 0 && bits == 0)
131		bits = dp * 16;
132
#	Line 131 | Line 134 | try_parse_v6_netmask(const char *text, s
134		deficit = bits / 16 + ((bits % 16) ? 1 : 0) - dp;
135
136		/* Now fill in the gaps(from ::) in the copied table... -A1kmm */
137	<	for (dp = 0, nyble = 0; dp < 8; dp++)
137	>	for (dp = 0, nyble = 0; dp < 8; ++dp)
138		{
139		if (nyble == finsert && deficit)
140		{
#	Line 145 | Line 148 | try_parse_v6_netmask(const char *text, s
148		/* Set unused bits to 0... -A1kmm */
149		if (bits < 128 && (bits % 16 != 0))
150		dc[bits / 16] &= ~((1 << (15 - bits % 16)) - 1);
151	<	for (dp = bits / 16 + (bits % 16 ? 1 : 0); dp < 8; dp++)
151	>	for (dp = bits / 16 + (bits % 16 ? 1 : 0); dp < 8; ++dp)
152		dc[dp] = 0;
153
154		/* And assign... -A1kmm */
155		if (addr)
156	<	for (dp = 0; dp < 8; dp++)
156	>	for (dp = 0; dp < 8; ++dp)
157		/* The cast is a kludge to make netbsd work. */
158		((unsigned short *)&v6->sin6_addr)[dp] = htons(dc[dp]);
159
160	<	if (b != NULL)
160	>	if (b)
161		*b = bits;
162		return HM_IPV6;
163		}
#	Line 170 | Line 173 | try_parse_v6_netmask(const char *text, s
173		static int
174		try_parse_v4_netmask(const char *text, struct irc_ssaddr *addr, int *b)
175		{
173	–	const char *p;
176		const char *digits[4];
177		unsigned char addb[4];
178		int n = 0, bits = 0;
#	Line 179 | Line 181 | try_parse_v4_netmask(const char *text, s
181
182		digits[n++] = text;
183
184	<	for (p = text; (c = *p); p++)
184	>	for (const char *p = text; (c = *p); ++p)
185	>	{
186		if (c >= '0' && c <= '9')   /* empty */
187		;
188		else if (c == '.')
#	Line 202 | Line 205 | try_parse_v4_netmask(const char *text, s
205		char *after;
206		bits = strtoul(p + 1, &after, 10);
207
208	<	if (!bits || *after)
208	>	if (bits < 0 || *after)
209		return HM_HOST;
210		if (bits > n * 8)
211		return HM_HOST;
#	Line 211 | Line 214 | try_parse_v4_netmask(const char *text, s
214		}
215		else
216		return HM_HOST;
217	+	}
218
219		if (n < 4 && bits == 0)
220		bits = n * 8;
#	Line 218 | Line 222 | try_parse_v4_netmask(const char *text, s
222		while (n < 4)
223		digits[n++] = "0";
224
225	<	for (n = 0; n < 4; n++)
225	>	for (n = 0; n < 4; ++n)
226		addb[n] = strtoul(digits[n], NULL, 10);
227
228		if (bits == 0)
#	Line 227 | Line 231 | try_parse_v4_netmask(const char *text, s
231		/* Set unused bits to 0... -A1kmm */
232		if (bits < 32 && bits % 8)
233		addb[bits / 8] &= ~((1 << (8 - bits % 8)) - 1);
234	<	for (n = bits / 8 + (bits % 8 ? 1 : 0); n < 4; n++)
234	>	for (n = bits / 8 + (bits % 8 ? 1 : 0); n < 4; ++n)
235		addb[n] = 0;
236		if (addr)
237		v4->sin_addr.s_addr =
238		htonl(addb[0] << 24 | addb[1] << 16 | addb[2] << 8 | addb[3]);
239	<	if (b != NULL)
239	>	if (b)
240		*b = bits;
241		return HM_IPV4;
242		}
#	Line 247 | Line 251 | try_parse_v4_netmask(const char *text, s
251		int
252		parse_netmask(const char *text, struct irc_ssaddr *addr, int *b)
253		{
254	+	if (strchr(text, '.'))
255	+	return try_parse_v4_netmask(text, addr, b);
256		#ifdef IPV6
257		if (strchr(text, ':'))
258		return try_parse_v6_netmask(text, addr, b);
259		#endif
254	–	if (strchr(text, '.'))
255	–	return try_parse_v4_netmask(text, addr, b);
260		return HM_HOST;
261		}
262
#	Line 264 | Line 268 | parse_netmask(const char *text, struct i
268		*/
269		#ifdef IPV6
270		int
271	<	match_ipv6(struct irc_ssaddr *addr, struct irc_ssaddr *mask, int bits)
271	>	match_ipv6(const struct irc_ssaddr *addr, const struct irc_ssaddr *mask, int bits)
272		{
273		int i, m, n = bits / 8;
274	<	struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
275	<	struct sockaddr_in6 *v6mask = (struct sockaddr_in6 *)mask;
274	>	const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr;
275	>	const struct sockaddr_in6 *v6mask = (const struct sockaddr_in6 *)mask;
276
277	<	for (i = 0; i < n; i++)
277	>	for (i = 0; i < n; ++i)
278		if (v6->sin6_addr.s6_addr[i] != v6mask->sin6_addr.s6_addr[i])
279		return 0;
280	+
281		if ((m = bits % 8) == 0)
282		return -1;
283		if ((v6->sin6_addr.s6_addr[n] & ~((1 << (8 - m)) - 1)) ==
#	Line 288 | Line 293 | match_ipv6(struct irc_ssaddr *addr, stru
293		* Side Effects: None
294		*/
295		int
296	<	match_ipv4(struct irc_ssaddr *addr, struct irc_ssaddr *mask, int bits)
296	>	match_ipv4(const struct irc_ssaddr *addr, const struct irc_ssaddr *mask, int bits)
297		{
298	<	struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
299	<	struct sockaddr_in *v4mask = (struct sockaddr_in *)mask;
298	>	const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr;
299	>	const struct sockaddr_in *v4mask = (const struct sockaddr_in *)mask;
300
301		if ((ntohl(v4->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1)) !=
302		ntohl(v4mask->sin_addr.s_addr))
#	Line 357 | Line 362 | init_host_hash(void)
362		* Side effects: None
363		*/
364		static uint32_t
365	<	hash_ipv4(struct irc_ssaddr *addr, int bits)
365	>	hash_ipv4(const struct irc_ssaddr *addr, int bits)
366		{
367		if (bits != 0)
368		{
369	<	struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
369	>	const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr;
370		uint32_t av = ntohl(v4->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1);
371
372		return (av ^ (av >> 12) ^ (av >> 24)) & (ATABLE_SIZE - 1);
#	Line 377 | Line 382 | hash_ipv4(struct irc_ssaddr *addr, int b
382		*/
383		#ifdef IPV6
384		static uint32_t
385	<	hash_ipv6(struct irc_ssaddr *addr, int bits)
385	>	hash_ipv6(const struct irc_ssaddr *addr, int bits)
386		{
387		uint32_t v = 0, n;
388	<	struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
388	>	const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr;
389
390	<	for (n = 0; n < 16; n++)
390	>	for (n = 0; n < 16; ++n)
391		{
392		if (bits >= 8)
393		{
#	Line 409 | Line 414 | hash_ipv6(struct irc_ssaddr *addr, int b
414		static uint32_t
415		hash_text(const char *start)
416		{
412	–	const char *p = start;
417		uint32_t h = 0;
418
419	<	for (; *p; ++p)
420	<	h = (h << 4) - (h + (unsigned char)ToLower(*p));
419	>	for (const char *p = start; *p; ++p)
420	>	h = (h << 4) - (h + ToLower(*p));
421
422		return h & (ATABLE_SIZE - 1);
423		}
#	Line 429 | Line 433 | get_mask_hash(const char *text)
433		{
434		const char *hp = "", *p;
435
436	<	for (p = text + strlen(text) - 1; p >= text; p--)
436	>	for (p = text + strlen(text) - 1; p >= text; --p)
437		if (IsMWildChar(*p))
438		return hash_text(hp);
439		else if (*p == '.')
#	Line 437 | Line 441 | get_mask_hash(const char *text)
441		return hash_text(text);
442		}
443
444	<	/* struct AccessItem *find_conf_by_address(const char *, struct irc_ssaddr *,
444	>	/* struct MaskItem *find_conf_by_address(const char *, struct irc_ssaddr *,
445		*                                         int type, int fam, const char *username)
446		* Input: The hostname, the address, the type of mask to find, the address
447		*        family, the username.
#	Line 445 | Line 449 | get_mask_hash(const char *text)
449		* Side-effects: None
450		* Note: Setting bit 0 of the type means that the username is ignored.
451		* Warning: IsNeedPassword for everything that is not an auth{} entry
452	<	* should always be true (i.e. aconf->flags & CONF_FLAGS_NEED_PASSWORD == 0)
452	>	* should always be true (i.e. conf->flags & CONF_FLAGS_NEED_PASSWORD == 0)
453		*/
454	<	struct AccessItem *
454	>	struct MaskItem *
455		find_conf_by_address(const char *name, struct irc_ssaddr *addr, unsigned int type,
456		int fam, const char *username, const char *password, int do_match)
457		{
458		unsigned int hprecv = 0;
459		dlink_node *ptr = NULL;
460	<	struct AccessItem *hprec = NULL;
461	<	struct AddressRec *arec;
460	>	struct MaskItem *hprec = NULL;
461	>	struct AddressRec *arec = NULL;
462		int b;
463		int (*cmpfunc)(const char *, const char *) = do_match ? match : irccmp;
464
461	–	if (username == NULL)
462	–	username = "";
463	–	if (password == NULL)
464	–	password = "";
465	–
465		if (addr)
466		{
467		/* Check for IPV6 matches... */
#	Line 473 | Line 472 | find_conf_by_address(const char *name, s
472		{
473		DLINK_FOREACH(ptr, atable[hash_ipv6(addr, b)].head)
474		{
475	<	arec = ptr->data;
475	>	arec = ptr->data;
476
477	<	if (arec->type == (type & ~0x1) &&
477	>	if ((arec->type == type) &&
478		arec->precedence > hprecv &&
479		arec->masktype == HM_IPV6 &&
480		match_ipv6(addr, &arec->Mask.ipa.addr,
481		arec->Mask.ipa.bits) &&
482	<	(type & 0x1 || cmpfunc(arec->username, username) == do_match) &&
483	<	(IsNeedPassword(arec->aconf) || arec->aconf->passwd == NULL ||
484	<	match_conf_password(password, arec->aconf)))
482	>	(!username || !cmpfunc(arec->username, username)) &&
483	>	(IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
484	>	match_conf_password(password, arec->conf)))
485		{
486		hprecv = arec->precedence;
487	<	hprec = arec->aconf;
487	>	hprec = arec->conf;
488		}
489		}
490		}
#	Line 500 | Line 499 | find_conf_by_address(const char *name, s
499		{
500		arec = ptr->data;
501
502	<	if (arec->type == (type & ~0x1) &&
502	>	if ((arec->type == type) &&
503		arec->precedence > hprecv &&
504		arec->masktype == HM_IPV4 &&
505		match_ipv4(addr, &arec->Mask.ipa.addr,
506		arec->Mask.ipa.bits) &&
507	<	(type & 0x1 || cmpfunc(arec->username, username) == do_match) &&
508	<	(IsNeedPassword(arec->aconf) || arec->aconf->passwd == NULL ||
509	<	match_conf_password(password, arec->aconf)))
507	>	(!username || !cmpfunc(arec->username, username)) &&
508	>	(IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
509	>	match_conf_password(password, arec->conf)))
510		{
511		hprecv = arec->precedence;
512	<	hprec = arec->aconf;
512	>	hprec = arec->conf;
513		}
514		}
515		}
516		}
517		}
518
519	<	if (name != NULL)
519	>	if (name)
520		{
521		const char *p = name;
522
#	Line 526 | Line 525 | find_conf_by_address(const char *name, s
525		DLINK_FOREACH(ptr, atable[hash_text(p)].head)
526		{
527		arec = ptr->data;
528	<	if ((arec->type == (type & ~0x1)) &&
528	>	if ((arec->type == type) &&
529		arec->precedence > hprecv &&
530		(arec->masktype == HM_HOST) &&
531	<	cmpfunc(arec->Mask.hostname, name) == do_match &&
532	<	(type & 0x1 || cmpfunc(arec->username, username) == do_match) &&
533	<	(IsNeedPassword(arec->aconf) || arec->aconf->passwd == NULL ||
534	<	match_conf_password(password, arec->aconf)))
531	>	!cmpfunc(arec->Mask.hostname, name) &&
532	>	(!username || !cmpfunc(arec->username, username)) &&
533	>	(IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
534	>	match_conf_password(password, arec->conf)))
535		{
536		hprecv = arec->precedence;
537	<	hprec = arec->aconf;
537	>	hprec = arec->conf;
538		}
539		}
540	<	p = strchr(p, '.');
541	<	if (p == NULL)
540	>
541	>	if ((p = strchr(p, '.')) == NULL)
542		break;
543	<	p++;
543	>	++p;
544		}
545
546		DLINK_FOREACH(ptr, atable[0].head)
547		{
548		arec = ptr->data;
549
550	<	if (arec->type == (type & ~0x1) &&
550	>	if (arec->type == type &&
551		arec->precedence > hprecv &&
552		arec->masktype == HM_HOST &&
553	<	cmpfunc(arec->Mask.hostname, name) == do_match &&
554	<	(type & 0x1 || cmpfunc(arec->username, username) == do_match) &&
555	<	(IsNeedPassword(arec->aconf) || arec->aconf->passwd == NULL ||
556	<	match_conf_password(password, arec->aconf)))
553	>	!cmpfunc(arec->Mask.hostname, name) &&
554	>	(!username || !cmpfunc(arec->username, username)) &&
555	>	(IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
556	>	match_conf_password(password, arec->conf)))
557		{
558		hprecv = arec->precedence;
559	<	hprec = arec->aconf;
559	>	hprec = arec->conf;
560		}
561		}
562		}
#	Line 565 | Line 564 | find_conf_by_address(const char *name, s
564		return hprec;
565		}
566
567	<	/* struct AccessItem* find_address_conf(const char*, const char*,
567	>	/* struct MaskItem* find_address_conf(const char*, const char*,
568		*                                     struct irc_ssaddr*, int, char *);
569		* Input: The hostname, username, address, address family.
570	<	* Output: The applicable AccessItem.
570	>	* Output: The applicable MaskItem.
571		* Side-effects: None
572		*/
573	<	struct AccessItem *
573	>	struct MaskItem *
574		find_address_conf(const char *host, const char *user,
575		struct irc_ssaddr *ip, int aftype, char *password)
576		{
577	<	struct AccessItem *iconf, *kconf;
577	>	struct MaskItem *authcnf = NULL, *killcnf = NULL;
578
579	<	/* Find the best I-line... If none, return NULL -A1kmm */
580	<	if ((iconf = find_conf_by_address(host, ip, CONF_CLIENT, aftype, user,
581	<	password, 1)) == NULL)
579	>	/* Find the best auth{} block... If none, return NULL -A1kmm */
580	>	if ((authcnf = find_conf_by_address(host, ip, CONF_CLIENT, aftype, user,
581	>	password, 1)) == NULL)
582		return NULL;
583
584	<	/* If they are exempt from K-lines, return the best I-line. -A1kmm */
585	<	if (IsConfExemptKline(iconf))
586	<	return iconf;
584	>	/* If they are exempt from K-lines, return the best auth{} block. -A1kmm */
585	>	if (IsConfExemptKline(authcnf))
586	>	return authcnf;
587
588		/* Find the best K-line... -A1kmm */
589	<	kconf = find_conf_by_address(host, ip, CONF_KLINE, aftype, user, NULL, 1);
589	>	killcnf = find_conf_by_address(host, ip, CONF_KLINE, aftype, user, NULL, 1);
590
591	<	/* If they are K-lined, return the K-line. Otherwise, return the
592	<	* I-line. -A1kmm */
593	<	if (kconf != NULL)
594	<	return kconf;
591	>	/*
592	>	* If they are K-lined, return the K-line. Otherwise, return the
593	>	* auth{} block. -A1kmm
594	>	*/
595	>	if (killcnf)
596	>	return killcnf;
597
598	<	kconf = find_conf_by_address(host, ip, CONF_GLINE, aftype, user, NULL, 1);
599	<	if (kconf != NULL && !IsConfExemptGline(iconf))
599	<	return kconf;
598	>	if (IsConfExemptGline(authcnf))
599	>	return authcnf;
600
601	<	return iconf;
602	<	}
601	>	killcnf = find_conf_by_address(host, ip, CONF_GLINE, aftype, user, NULL, 1);
602	>	if (killcnf)
603	>	return killcnf;
604
605	<	struct AccessItem *
605	<	find_gline_conf(const char *host, const char *user,
606	<	struct irc_ssaddr *ip, int aftype)
607	<	{
608	<	struct AccessItem *eline;
609	<
610	<	eline = find_conf_by_address(host, ip, CONF_EXEMPTKLINE, aftype,
611	<	user, NULL, 1);
612	<	if (eline != NULL)
613	<	return eline;
614	<
615	<	return find_conf_by_address(host, ip, CONF_GLINE, aftype, user, NULL, 1);
616	<	}
617	<
618	<	/* find_kline_conf
619	<	*
620	<	* inputs       - pointer to hostname
621	<	*              - pointer to username
622	<	*              - incoming IP and type (IPv4 vs. IPv6)
623	<	* outut        - pointer to kline conf if found NULL if not
624	<	* side effects -
625	<	*/
626	<	struct AccessItem *
627	<	find_kline_conf(const char *host, const char *user,
628	<	struct irc_ssaddr *ip, int aftype)
629	<	{
630	<	struct AccessItem *eline;
631	<
632	<	eline = find_conf_by_address(host, ip, CONF_EXEMPTKLINE, aftype,
633	<	user, NULL, 1);
634	<	if (eline != NULL)
635	<	return eline;
636	<
637	<	return find_conf_by_address(host, ip, CONF_KLINE, aftype, user, NULL, 1);
605	>	return authcnf;
606		}
607
608	<	/* struct AccessItem* find_dline_conf(struct irc_ssaddr*, int)
608	>	/* struct MaskItem* find_dline_conf(struct irc_ssaddr*, int)
609		*
610		* Input:       An address, an address family.
611		* Output:      The best matching D-line or exempt line.
612		* Side effects: None.
613		*/
614	<	struct AccessItem *
614	>	struct MaskItem *
615		find_dline_conf(struct irc_ssaddr *addr, int aftype)
616		{
617	<	struct AccessItem *eline;
617	>	struct MaskItem *eline;
618
619	<	eline = find_conf_by_address(NULL, addr, CONF_EXEMPTDLINE | 1, aftype,
620	<	NULL, NULL, 1);
653	<	if (eline != NULL)
619	>	eline = find_conf_by_address(NULL, addr, CONF_EXEMPT, aftype, NULL, NULL, 1);
620	>	if (eline)
621		return eline;
622
623	<	return find_conf_by_address(NULL, addr, CONF_DLINE | 1, aftype, NULL, NULL, 1);
623	>	return find_conf_by_address(NULL, addr, CONF_DLINE, aftype, NULL, NULL, 1);
624		}
625
626	<	/* void add_conf_by_address(int, struct AccessItem *aconf)
627	<	* Input:
626	>	/* void add_conf_by_address(int, struct MaskItem *aconf)
627	>	* Input:
628		* Output: None
629		* Side-effects: Adds this entry to the hash table.
630		*/
631	<	void
632	<	add_conf_by_address(const unsigned int type, struct AccessItem *aconf)
631	>	struct AddressRec *
632	>	add_conf_by_address(const unsigned int type, struct MaskItem *conf)
633		{
634	<	const char *address;
635	<	const char *username;
634	>	const char *hostname = conf->host;
635	>	const char *username = conf->user;
636		static unsigned int prec_value = 0xFFFFFFFF;
637		int bits = 0;
638	<	struct AddressRec *arec;
672	<
673	<	address = aconf->host;
674	<	username = aconf->user;
638	>	struct AddressRec *arec = NULL;
639
640	<	assert(type != 0);
677	<	assert(aconf != NULL);
640	>	assert(type && !EmptyString(hostname));
641
642	<	if (EmptyString(address))
643	<	address = "/NOMATCH!/";
681	<
682	<	arec = MyMalloc(sizeof(struct AddressRec));
683	<	arec->masktype = parse_netmask(address, &arec->Mask.ipa.addr, &bits);
642	>	arec = MyCalloc(sizeof(struct AddressRec));
643	>	arec->masktype = parse_netmask(hostname, &arec->Mask.ipa.addr, &bits);
644		arec->Mask.ipa.bits = bits;
645		arec->username = username;
646	<	arec->aconf = aconf;
646	>	arec->conf = conf;
647		arec->precedence = prec_value--;
648		arec->type = type;
649
#	Line 702 | Line 662 | add_conf_by_address(const unsigned int t
662		break;
663		#endif
664		default: /* HM_HOST */
665	<	arec->Mask.hostname = address;
666	<	dlinkAdd(arec, &arec->node, &atable[get_mask_hash(address)]);
665	>	arec->Mask.hostname = hostname;
666	>	dlinkAdd(arec, &arec->node, &atable[get_mask_hash(hostname)]);
667		break;
668		}
669	+
670	+	return arec;
671		}
672
673	<	/* void delete_one_address(const char*, struct AccessItem*)
674	<	* Input: An address string, the associated AccessItem.
673	>	/* void delete_one_address(const char*, struct MaskItem*)
674	>	* Input: An address string, the associated MaskItem.
675		* Output: None
676	<	* Side effects: Deletes an address record. Frees the AccessItem if there
676	>	* Side effects: Deletes an address record. Frees the MaskItem if there
677		*               is nothing referencing it, sets it as illegal otherwise.
678		*/
679		void
680	<	delete_one_address_conf(const char *address, struct AccessItem *aconf)
680	>	delete_one_address_conf(const char *address, struct MaskItem *conf)
681		{
682		int bits = 0;
683		uint32_t hv = 0;
#	Line 745 | Line 707 | delete_one_address_conf(const char *addr
707		{
708		struct AddressRec *arec = ptr->data;
709
710	<	if (arec->aconf == aconf)
710	>	if (arec->conf == conf)
711		{
712		dlinkDelete(&arec->node, &atable[hv]);
751	–	aconf->status |= CONF_ILLEGAL;
713
714	<	if (!aconf->clients)
715	<	free_access_item(aconf);
714	>	if (!conf->ref_count)
715	>	conf_free(conf);
716
717		MyFree(arec);
718		return;
#	Line 763 | Line 724 | delete_one_address_conf(const char *addr
724		* Input: None
725		* Output: None
726		* Side effects: Clears out all address records in the hash table,
727	<	*               frees them, and frees the AccessItems if nothing references
728	<	*               them, otherwise sets them as illegal.
727	>	*               frees them, and frees the MaskItems if nothing references
728	>	*               them, otherwise sets them as illegal.
729		*/
730		void
731		clear_out_address_conf(void)
732		{
772	–	unsigned int i = 0;
733		dlink_node *ptr = NULL, *ptr_next = NULL;
734	<
735	<	for (i = 0; i < ATABLE_SIZE; ++i)
734	>
735	>	for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
736		{
737		DLINK_FOREACH_SAFE(ptr, ptr_next, atable[i].head)
738		{
739		struct AddressRec *arec = ptr->data;
740
741	<	/* We keep the temporary K-lines and destroy the
742	<	* permanent ones, just to be confusing :) -A1kmm
743	<	*/
744	<	if (!(arec->aconf->flags & CONF_FLAGS_TEMPORARY))
745	<	{
746	<	dlinkDelete(&arec->node, &atable[i]);
747	<	/* unlink it from link list - Dianora */
748	<	arec->aconf->status |= CONF_ILLEGAL;
749	<
750	<	if (!arec->aconf->clients)
751	<	free_access_item(arec->aconf);
752	<	MyFree(arec);
793	<	}
741	>	/*
742	>	* We keep the temporary K-lines and destroy the permanent ones,
743	>	* just to be confusing :) -A1kmm
744	>	*/
745	>	if (arec->conf->until || IsConfDatabase(arec->conf))
746	>	continue;
747	>
748	>	dlinkDelete(&arec->node, &atable[i]);
749	>
750	>	if (!arec->conf->ref_count)
751	>	conf_free(arec->conf);
752	>	MyFree(arec);
753		}
754		}
755		}
#	Line 814 | Line 773 | hostmask_send_expiration(struct AddressR
773		case CONF_GLINE:
774		ban_type = 'G';
775		break;
776	+	default: break;
777		}
778	<
779	<	sendto_realops_flags(UMODE_ALL, L_ALL,
778	>
779	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
780		"Temporary %c-line for [%s@%s] expired", ban_type,
781	<	(arec->aconf->user) ? arec->aconf->user : "*",
782	<	(arec->aconf->host) ? arec->aconf->host : "*");
781	>	(arec->conf->user) ? arec->conf->user : "*",
782	>	(arec->conf->host) ? arec->conf->host : "*");
783		}
784
785		void
786		hostmask_expire_temporary(void)
787		{
828	–	unsigned int i = 0;
788		dlink_node *ptr = NULL, *ptr_next = NULL;
789
790	<	for (i = 0; i < ATABLE_SIZE; ++i)
790	>	for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
791		{
792		DLINK_FOREACH_SAFE(ptr, ptr_next, atable[i].head)
793		{
794		struct AddressRec *arec = ptr->data;
795
796	<	if (!IsConfTemporary(arec->aconf) || arec->aconf->hold > CurrentTime)
796	>	if (!arec->conf->until || arec->conf->until > CurrentTime)
797		continue;
798
799		switch (arec->type)
#	Line 845 | Line 804 | hostmask_expire_temporary(void)
804		hostmask_send_expiration(arec);
805
806		dlinkDelete(&arec->node, &atable[i]);
807	<	free_access_item(arec->aconf);
807	>	conf_free(arec->conf);
808		MyFree(arec);
809		break;
810	+	default: break;
811		}
812		}
813		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)